From 62dc0d7403b06cfc67e6b11a6ca1f64469541b89 Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@parity.io>
Date: Sat, 30 Apr 2022 12:34:22 +0200
Subject: [PATCH 01/43] New Society

---
 bin/node/runtime/src/lib.rs              |    2 +-
 frame/society/src/lib.rs                 | 1575 +++++++++++-----------
 frame/society/src/mock.rs                |    2 +-
 frame/support/src/storage/bounded_vec.rs |   25 +-
 frame/support/src/storage/types/map.rs   |   16 +
 frame/system/src/lib.rs                  |    4 +-
 primitives/core/src/ecdsa.rs             |    8 +
 primitives/core/src/ed25519.rs           |    8 +
 primitives/core/src/sr25519.rs           |   10 +-
 primitives/core/src/traits.rs            |    7 +
 primitives/runtime/src/lib.rs            |   13 +-
 11 files changed, 868 insertions(+), 802 deletions(-)

diff --git a/bin/node/runtime/src/lib.rs b/bin/node/runtime/src/lib.rs
index 18ce64c29f8e8..fcdf5fc8cdd01 100644
--- a/bin/node/runtime/src/lib.rs
+++ b/bin/node/runtime/src/lib.rs
@@ -1280,7 +1280,7 @@ impl pallet_society::Config for Runtime {
 	type MaxLockDuration = MaxLockDuration;
 	type FounderSetOrigin =
 		pallet_collective::EnsureProportionMoreThan<AccountId, CouncilCollective, 1, 2>;
-	type SuspensionJudgementOrigin = pallet_society::EnsureFounder<Runtime>;
+	type JudgementOrigin = pallet_society::EnsureFounder<Runtime>;
 	type MaxCandidateIntake = MaxCandidateIntake;
 	type ChallengePeriod = ChallengePeriod;
 }
diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index 6ad63d2102c53..b18140fc989e8 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -242,6 +242,9 @@
 //! * `set_max_membership` - The ROOT origin can update the maximum member count for the society.
 //! The max membership count must be greater than 1.
 
+// TODO: Sort out all the `limit: None` stuff for remove prefix.
+// TODO: Membership subsets: ranks and badges.
+
 // Ensure we're `no_std` when compiling for Wasm.
 #![cfg_attr(not(feature = "std"), no_std)]
 
@@ -267,10 +270,10 @@ use rand_chacha::{
 use scale_info::TypeInfo;
 use sp_runtime::{
 	traits::{
-		AccountIdConversion, CheckedSub, Hash, IntegerSquareRoot, Saturating, StaticLookup,
-		TrailingZeroInput, Zero,
+		AccountIdConversion, CheckedAdd, CheckedSub, Hash, IntegerSquareRoot, Saturating,
+		StaticLookup, TrailingZeroInput, Zero,
 	},
-	Percent, RuntimeDebug,
+	ArithmeticError::Overflow, Percent, RuntimeDebug,
 };
 use sp_std::prelude::*;
 
@@ -284,7 +287,7 @@ type NegativeImbalanceOf<T, I> = <<T as Config<I>>::Currency as Currency<
 
 /// A vote by a member on a candidate application.
 #[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
-pub enum Vote {
+pub enum OldVote {
 	/// The member has been chosen to be skeptic and has not yet taken any action.
 	Skeptic,
 	/// The member has rejected the candidate's application.
@@ -293,6 +296,11 @@ pub enum Vote {
 	Approve,
 }
 
+pub struct Vote {
+	approve: bool,
+	weight: u32,
+}
+
 /// A judgement by the suspension judgement origin on a suspended candidate.
 #[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
 pub enum Judgement {
@@ -341,6 +349,27 @@ pub struct Bid<AccountId, Balance> {
 	value: Balance,
 }
 
+/// The index of a round of candidates.
+pub type RoundIndex = u32;
+
+/// The rank of a member.
+pub type Rank = u32;
+
+/// A bid for entry into society.
+#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub struct Candidacy<AccountId, Balance> {
+	/// The index of the round where the candidacy began.
+	round: RoundIndex,
+	/// The kind of bid placed for this bidder/candidate. See `BidKind`.
+	kind: BidKind<AccountId, Balance>,
+	/// The reward that the bidder has requested for successfully joining the society.
+	bid: Balance,
+	/// The tally of explicit approval votes so far.
+	approvals: u32,
+	/// The tally of explicit rejection votes so far.
+	rejections: u32,
+}
+
 /// A vote by a member on a candidate application.
 #[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
 pub enum BidKind<AccountId, Balance> {
@@ -365,6 +394,41 @@ impl<AccountId: PartialEq, Balance> BidKind<AccountId, Balance> {
 	}
 }
 
+pub type PayoutsFor<T, I> = BoundedVec<
+	(<T as frame_system::Config>::BlockNumber, BalanceOf<T, I>),
+	<T as Config<I>>::MaxPayouts,
+>;
+
+/// Information concerning a member.
+#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub struct MemberRecord<Balance, BlockNumber, MaxPayouts> {
+	rank: Rank,
+	strikes: StrikeCount,
+	vouching: Option<VouchingStatus>,
+	paid: Balance,
+	index: u32,
+	payouts: BoundedVec<(BlockNumber, Balance), MaxPayouts>,
+}
+
+pub type MemberRecordFor<T, I> = MemberRecord<
+	BalanceOf<T, I>,
+	<T as frame_system::Config>::BlockNumber,
+	<T as Config<I>>::MaxPayouts,
+>;
+
+/// Record for an individual new member who was elevated from a candidate recently.
+#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub struct IntakeRecord<AccountId, Balance> {
+	who: AccountId,
+	bid: Balance,
+	round: RoundIndex,
+}
+
+pub type IntakeRecordFor<T, I> = IntakeRecord<
+	<T as frame_system::Config>::AccountId,
+	BalanceOf<T, I>,
+>;
+
 #[frame_support::pallet]
 pub mod pallet {
 	use super::*;
@@ -398,21 +462,29 @@ pub mod pallet {
 		#[pallet::constant]
 		type WrongSideDeduction: Get<BalanceOf<Self, I>>;
 
-		/// The number of times a member may vote the wrong way (or not at all, when they are a
-		/// skeptic) before they become suspended.
+		/// The number of times a skeptic may not vote or vote the wrong way for a candidate before
+		/// they become suspended.
 		#[pallet::constant]
 		type MaxStrikes: Get<u32>;
 
+		/// The number of times a skeptic may not vote or vote the wrong way for a candidate before
+		/// they get any payouts slashed in half.
+		#[pallet::constant]
+		type GraceStrikes: Get<u32>;
+
 		/// The amount of incentive paid within each period. Doesn't include VoterTip.
 		#[pallet::constant]
 		type PeriodSpend: Get<BalanceOf<Self, I>>;
 
-		/// The receiver of the signal for when the members have changed.
-		type MembershipChanged: ChangeMembers<Self::AccountId>;
+		/// 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.
+		#[pallet::constant]
+		type VotingPeriod: Get<Self::BlockNumber>;
 
-		/// The number of blocks between candidate/membership rotation periods.
+		/// The number of blocks on which new candidates can claim their membership and be the
+		/// named head.
 		#[pallet::constant]
-		type RotationPeriod: Get<Self::BlockNumber>;
+		type ClaimPeriod: Get<Self::BlockNumber>;
 
 		/// The maximum duration of the payout lock.
 		#[pallet::constant]
@@ -422,7 +494,7 @@ pub mod pallet {
 		type FounderSetOrigin: EnsureOrigin<Self::Origin>;
 
 		/// The origin that is allowed to make suspension judgements.
-		type SuspensionJudgementOrigin: EnsureOrigin<Self::Origin>;
+		type JudgementOrigin: EnsureOrigin<Self::Origin>;
 
 		/// The number of blocks between membership challenges.
 		#[pallet::constant]
@@ -431,6 +503,17 @@ pub mod pallet {
 		/// The maximum number of candidates that we accept per round.
 		#[pallet::constant]
 		type MaxCandidateIntake: Get<u32>;
+
+		/// The origin that is allowed to set the maximum number of members.
+		type AdminOrigin: Get<u32>;
+
+		/// The maximum number of payouts a member may have waiting unclaimed.
+		#[pallet::constant]
+		type MaxPayouts: Get<u32>;
+
+		/// The maximum number of bids at once.
+		#[pallet::constant]
+		type MaxBids: Get<u32>;
 	}
 
 	#[pallet::error]
@@ -471,6 +554,20 @@ pub mod pallet {
 		NotFounder,
 		/// The caller is not the head.
 		NotHead,
+		/// The membership cannot be claimed as the member does not (yet) have enough votes.
+		NotApproved,
+		/// The candidacy cannot be claimed/dropped as the voting is still in progress.
+		InProgress,
+		/// The candidacy cannot be dropped as the candidate is approved.
+		Approved,
+		/// The candidacy cannot be pruned until a full additional intake period has passed.
+		TooEarly,
+		/// The skeptic already voted.
+		Voted,
+		/// The skeptic need not vote on candidates from expired rounds.
+		Expired,
+		/// User is not a bidder.
+		NotBidder,
 	}
 
 	#[pallet::event]
@@ -513,100 +610,147 @@ pub mod pallet {
 		Deposit { value: BalanceOf<T, I> },
 	}
 
+	/// Old name generated by `decl_event`.
+	#[deprecated(note = "use `Event` instead")]
+	pub type RawEvent<T, I = ()> = Event<T, I>;
+
+	/// The max number of members for the society at one time.
+	#[pallet::storage]
+	pub(super) type MaxMembers<T: Config<I>, I: 'static = ()> = StorageValue<_, u32, ValueQuery>;
+
+	/// Amount of our account balance that is specifically for the next round's bid(s).
+	#[pallet::storage]
+	pub type Pot<T: Config<I>, I: 'static = ()> = StorageValue<_, BalanceOf<T, I>, ValueQuery>;
+
 	/// The first member.
 	#[pallet::storage]
-	#[pallet::getter(fn founder)]
 	pub type Founder<T: Config<I>, I: 'static = ()> = StorageValue<_, T::AccountId>;
 
+	/// The most primary from the most recently approved members.
+	#[pallet::storage]
+	pub type Head<T: Config<I>, I: 'static = ()> = StorageValue<_, T::AccountId>;
+
 	/// A hash of the rules of this society concerning membership. Can only be set once and
 	/// only by the founder.
+	// TODO: Should be a map with rules for each rank and badge.
 	#[pallet::storage]
-	#[pallet::getter(fn rules)]
 	pub type Rules<T: Config<I>, I: 'static = ()> = StorageValue<_, T::Hash>;
 
-	/// The current set of candidates; bidders that are attempting to become members.
-	#[pallet::storage]
-	#[pallet::getter(fn candidates)]
-	pub type Candidates<T: Config<I>, I: 'static = ()> =
-		StorageValue<_, Vec<Bid<T::AccountId, BalanceOf<T, I>>>, ValueQuery>;
-
-	/// The set of suspended candidates.
-	#[pallet::storage]
-	#[pallet::getter(fn suspended_candidate)]
-	pub type SuspendedCandidates<T: Config<I>, I: 'static = ()> = StorageMap<
-		_,
-		Twox64Concat,
-		T::AccountId,
-		(BalanceOf<T, I>, BidKind<T::AccountId, BalanceOf<T, I>>),
-	>;
-
-	/// Amount of our account balance that is specifically for the next round's bid(s).
+	/// The current members and their rank. Doesn't include `SuspendedMembers`.
 	#[pallet::storage]
-	#[pallet::getter(fn pot)]
-	pub type Pot<T: Config<I>, I: 'static = ()> = StorageValue<_, BalanceOf<T, I>, ValueQuery>;
+	pub type Membership<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Twox64Concat, T::AccountId, MemberRecordFor<T>, OptionQuery>;
 
-	/// The most primary from the most recently approved members.
+	/// The number of items in `Membership` currently. (Doesn't include `SuspendedMembers`.)
 	#[pallet::storage]
-	#[pallet::getter(fn head)]
-	pub type Head<T: Config<I>, I: 'static = ()> = StorageValue<_, T::AccountId>;
+	pub type MemberCount<T: Config<I>, I: 'static = ()> = StorageValue<_, u32, ValueQuery>;
 
-	/// The current set of members, ordered.
+	/// The current items in `Membership` keyed by their unique index. Keys are densely populated
+	/// `0..MemberCount` (does not include `MemberCount`).
 	#[pallet::storage]
-	#[pallet::getter(fn members)]
-	pub type Members<T: Config<I>, I: 'static = ()> =
-		StorageValue<_, Vec<T::AccountId>, ValueQuery>;
+	pub type MemberByIndex<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Twox64Concat, u32, T::AccountId, OptionQuery>;
 
 	/// The set of suspended members.
 	#[pallet::storage]
-	#[pallet::getter(fn suspended_member)]
 	pub type SuspendedMembers<T: Config<I>, I: 'static = ()> =
-		StorageMap<_, Twox64Concat, T::AccountId, bool, ValueQuery>;
+		StorageMap<_, Twox64Concat, T::AccountId, MemberRecordFor<T>, OptionQuery>;
 
-	/// The current bids, stored ordered by the value of the bid.
+	/// The number of rounds which have passed.
 	#[pallet::storage]
-	pub(super) type Bids<T: Config<I>, I: 'static = ()> =
-		StorageValue<_, Vec<Bid<T::AccountId, BalanceOf<T, I>>>, ValueQuery>;
+	pub type RoundCount<T: Config<I>, I: 'static = ()> = StorageValue<_, RoundIndex, ValueQuery>;
 
-	/// Members currently vouching or banned from vouching again
+	/// The current bids, stored ordered by the value of the bid.
 	#[pallet::storage]
-	#[pallet::getter(fn vouching)]
-	pub(super) type Vouching<T: Config<I>, I: 'static = ()> =
-		StorageMap<_, Twox64Concat, T::AccountId, VouchingStatus>;
+	pub(super) type Bids<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, BoundedVec<Bid<T::AccountId, BalanceOf<T, I>>, T::MaxBids>, ValueQuery>;
 
-	/// Pending payouts; ordered by block number, with the amount that should be paid out.
 	#[pallet::storage]
-	pub(super) type Payouts<T: Config<I>, I: 'static = ()> = StorageMap<
-		_,
-		Twox64Concat,
+	pub type Candidate<T: Config<I>, I: 'static = ()> = StorageMap<_,
+		Blake2_128Concat,
 		T::AccountId,
-		Vec<(T::BlockNumber, BalanceOf<T, I>)>,
-		ValueQuery,
+		Candidacy<T::AccountId, BalanceOf<T, I>>,
+		OptionQuery,
 	>;
 
-	/// The ongoing number of losing votes cast by the member.
+	/// The current skeptics.
 	#[pallet::storage]
-	pub(super) type Strikes<T: Config<I>, I: 'static = ()> =
-		StorageMap<_, Twox64Concat, T::AccountId, StrikeCount, ValueQuery>;
+	pub type Skeptic<T: Config<I>, I: 'static = ()> = StorageValue<_, Vec<T::AccountId>, ValueQuery>;
 
 	/// Double map from Candidate -> Voter -> (Maybe) Vote.
 	#[pallet::storage]
-	pub(super) type Votes<T: Config<I>, I: 'static = ()> =
-		StorageDoubleMap<_, Twox64Concat, T::AccountId, Twox64Concat, T::AccountId, Vote>;
+	pub(super) type Votes<T: Config<I>, I: 'static = ()> = StorageDoubleMap<_,
+		Twox64Concat,
+		T::AccountId,
+		Twox64Concat,
+		T::AccountId,
+		Vote,
+		OptionQuery,
+	>;
+	// TODO: Migrate from:
+	//pub(super) type Votes<T: Config<I>, I: 'static = ()> =
+	//	StorageDoubleMap<_, Twox64Concat, T::AccountId, Twox64Concat, T::AccountId, OldVote>;
+
+	/// At the end of the claim period, this contains the most recently approved members (along with
+	/// their bid and round ID) who is from the most recent round with the lowest bid. They will
+	/// become the new `Head`.
+	#[pallet::storage]
+	pub type NextHead<T: Config<I>, I: 'static = ()> = StorageValue<_,
+		IntakeRecordFor<T>,
+		OptionQuery,
+	>;
 
-	/// The defending member currently being challenged.
+	/// The defending member currently being challenged, along with a running tally of approval and
+	/// rejection votes.
 	#[pallet::storage]
-	#[pallet::getter(fn defender)]
-	pub(super) type Defender<T: Config<I>, I: 'static = ()> = StorageValue<_, T::AccountId>;
+	pub(super) type Defending<T: Config<I>, I: 'static = ()> = StorageValue<_, (T::AccountId, T::AccountId, u32, u32)>;
 
 	/// Votes for the defender.
+	// TODO: Migrate (used to be `OldVote`)
 	#[pallet::storage]
 	pub(super) type DefenderVotes<T: Config<I>, I: 'static = ()> =
 		StorageMap<_, Twox64Concat, T::AccountId, Vote>;
 
-	/// The max number of members for the society at one time.
+	// OLD STUFF
+
+	// Moved to `Member`.
+	// TODO: Needs refactor, migration into Membership, removal.
+	/// Members currently vouching or banned from vouching again.
 	#[pallet::storage]
-	#[pallet::getter(fn max_members)]
-	pub(super) type MaxMembers<T: Config<I>, I: 'static = ()> = StorageValue<_, u32, ValueQuery>;
+	pub(super) type Vouching<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Twox64Concat, T::AccountId, VouchingStatus>;
+
+	/// The ongoing number of losing votes cast by the member.
+	// TODO: Needs refactor, migration into Membership, removal.
+	#[pallet::storage]
+	pub(super) type Strikes<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Twox64Concat, T::AccountId, StrikeCount, ValueQuery>;
+
+	/// The current set of members, ordered.
+	// TODO: Needs refactor, migration into Membership, removal.
+	#[pallet::storage]
+	#[pallet::getter(fn members)]
+	pub type Members<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, Vec<T::AccountId>, ValueQuery>;
+
+	/// The current set of candidates; bidders that are attempting to become members.
+	// TODO: Needs refactor, migration into Candidate, removal.
+	#[pallet::storage]
+	#[pallet::getter(fn candidates)]
+	pub type Candidates<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, Vec<Bid<T::AccountId, BalanceOf<T, I>>>, ValueQuery>;
+
+	/// The set of suspended candidates.
+	// TODO: Needs refactor and removal.
+	// TODO: Ensure that it is empty immediately prior to upgrade.
+	#[pallet::storage]
+	#[pallet::getter(fn suspended_candidate)]
+	pub type SuspendedCandidates<T: Config<I>, I: 'static = ()> = StorageMap<
+		_,
+		Twox64Concat,
+		T::AccountId,
+		(BalanceOf<T, I>, BidKind<T::AccountId, BalanceOf<T, I>>),
+	>;
 
 	#[pallet::hooks]
 	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {
@@ -616,22 +760,28 @@ pub mod pallet {
 			let mut weight = 0;
 			let weights = T::BlockWeights::get();
 
-			// Run a candidate/membership rotation
-			if (n % T::RotationPeriod::get()).is_zero() {
-				members = <Members<T, I>>::get();
-				Self::rotate_period(&mut members);
+			let phrase = b"society_rotation";
+			// we'll need a random seed here.
+			// TODO: deal with randomness freshness
+			// https://github.com/paritytech/substrate/issues/8312
+			let (seed, _) = T::Randomness::random(phrase);
+			// seed needs to be guaranteed to be 32 bytes.
+			let seed = <[u8; 32]>::decode(&mut TrailingZeroInput::new(seed.as_ref()))
+				.expect("input is padded with zeroes; qed");
+			let mut rng = ChaChaRng::from_seed(seed);
 
-				weight += weights.max_block / 20;
+			// Run a candidate/membership rotation
+			match Self::period() {
+				Period::Voting { elapsed: 0, .. } => {
+					Self::rotate_intake(&mut rng);
+					weight += weights.max_block / 20;
+				},
+				_ => {}
 			}
 
 			// Run a challenge rotation
 			if (n % T::ChallengePeriod::get()).is_zero() {
-				// Only read members if not already read.
-				if members.is_empty() {
-					members = <Members<T, I>>::get();
-				}
-				Self::rotate_challenge(&mut members);
-
+				Self::rotate_challenge(&mut rng);
 				weight += weights.max_block / 20;
 			}
 
@@ -685,46 +835,22 @@ pub mod pallet {
 		/// Parameters:
 		/// - `value`: A one time payment the bid would like to receive when joining the society.
 		///
-		/// # <weight>
 		/// Key: B (len of bids), C (len of candidates), M (len of members), X (balance reserve)
-		/// - Storage Reads:
-		/// 	- One storage read to check for suspended candidate. O(1)
-		/// 	- One storage read to check for suspended member. O(1)
-		/// 	- One storage read to retrieve all current bids. O(B)
-		/// 	- One storage read to retrieve all current candidates. O(C)
-		/// 	- One storage read to retrieve all members. O(M)
-		/// - Storage Writes:
-		/// 	- One storage mutate to add a new bid to the vector O(B) (TODO: possible optimization
-		///    w/ read)
-		/// 	- Up to one storage removal if bid.len() > MAX_BID_COUNT. O(1)
-		/// - Notable Computation:
-		/// 	- O(B + C + log M) search to check user is not already a part of society.
-		/// 	- O(log B) search to insert the new bid sorted.
-		/// - External Pallet Operations:
-		/// 	- One balance reserve operation. O(X)
-		/// 	- Up to one balance unreserve operation if bids.len() > MAX_BID_COUNT.
-		/// - Events:
-		/// 	- One event for new bid.
-		/// 	- Up to one event for AutoUnbid if bid.len() > MAX_BID_COUNT.
-		///
 		/// Total Complexity: O(M + B + C + logM + logB + X)
-		/// # </weight>
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
 		pub fn bid(origin: OriginFor<T>, value: BalanceOf<T, I>) -> DispatchResult {
 			let who = ensure_signed(origin)?;
-			ensure!(!<SuspendedCandidates<T, I>>::contains_key(&who), Error::<T, I>::Suspended);
-			ensure!(!<SuspendedMembers<T, I>>::contains_key(&who), Error::<T, I>::Suspended);
-			let bids = <Bids<T, I>>::get();
-			ensure!(!Self::is_bid(&bids, &who), Error::<T, I>::AlreadyBid);
-			let candidates = <Candidates<T, I>>::get();
-			ensure!(!Self::is_candidate(&candidates, &who), Error::<T, I>::AlreadyCandidate);
-			let members = <Members<T, I>>::get();
-			ensure!(!Self::is_member(&members, &who), Error::<T, I>::AlreadyMember);
+			ensure!(!SuspendedMembers::<T, I>::contains_key(&who), Error::<T, I>::Suspended);
+			let mut bids = Bids::<T, I>::get();
+			ensure!(!Self::has_bid(&bids, &who), Error::<T, I>::AlreadyBid);
+			ensure!(!Candidate::<T, I>::contains_key(&who), Error::<T, I>::AlreadyCandidate);
+			ensure!(!Membership::<T, I>::contains_key(&who), Error::<T, I>::AlreadyMember);
 
 			let deposit = T::CandidateDeposit::get();
 			T::Currency::reserve(&who, deposit)?;
 
-			Self::put_bid(bids, &who, value.clone(), BidKind::Deposit(deposit));
+			Self::insert_bid(&mut bids, &who, value.clone(), BidKind::Deposit(deposit));
+			Bids::<T, I>::put(bids);
 			Self::deposit_event(Event::<T, I>::Bid { candidate_id: who, offer: value });
 			Ok(())
 		}
@@ -737,42 +863,18 @@ pub mod pallet {
 		///
 		/// The dispatch origin for this call must be _Signed_ and a bidder.
 		///
-		/// Parameters:
-		/// - `pos`: Position in the `Bids` vector of the bid who wants to unbid.
-		///
-		/// # <weight>
 		/// Key: B (len of bids), X (balance unreserve)
-		/// - One storage read and write to retrieve and update the bids. O(B)
-		/// - Either one unreserve balance action O(X) or one vouching storage removal. O(1)
-		/// - One event.
-		///
 		/// Total Complexity: O(B + X)
-		/// # </weight>
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
-		pub fn unbid(origin: OriginFor<T>, pos: u32) -> DispatchResult {
+		pub fn unbid(origin: OriginFor<T>) -> DispatchResult {
 			let who = ensure_signed(origin)?;
 
-			let pos = pos as usize;
-			<Bids<T, I>>::mutate(|b| {
-				if pos < b.len() && b[pos].who == who {
-					// Either unreserve the deposit or free up the vouching member.
-					// In neither case can we do much if the action isn't completable, but there's
-					// no reason that either should fail.
-					match b.remove(pos).kind {
-						BidKind::Deposit(deposit) => {
-							let err_amount = T::Currency::unreserve(&who, deposit);
-							debug_assert!(err_amount.is_zero());
-						},
-						BidKind::Vouch(voucher, _) => {
-							<Vouching<T, I>>::remove(&voucher);
-						},
-					}
-					Self::deposit_event(Event::<T, I>::Unbid { candidate: who });
-					Ok(())
-				} else {
-					Err(Error::<T, I>::BadPosition)?
-				}
-			})
+			let mut bids = Bids::<T, I>::get();
+			let pos = bids.iter().position(|bid| bid.who == who).ok_or(Error::<T, I>::NotBidder)?;
+			Self::clean_bid(&bids.remove(pos));
+			Bids::<T, I>::put(bids);
+			Self::deposit_event(Event::<T, I>::Unbid { candidate: who });
+			Ok(())
 		}
 
 		/// As a member, vouch for someone to join society by placing a bid on their behalf.
@@ -793,33 +895,8 @@ pub mod pallet {
 		/// - `tip`: Your cut of the total `value` payout when the candidate is inducted into
 		/// the society. Tips larger than `value` will be saturated upon payout.
 		///
-		/// # <weight>
 		/// Key: B (len of bids), C (len of candidates), M (len of members)
-		/// - Storage Reads:
-		/// 	- One storage read to retrieve all members. O(M)
-		/// 	- One storage read to check member is not already vouching. O(1)
-		/// 	- One storage read to check for suspended candidate. O(1)
-		/// 	- One storage read to check for suspended member. O(1)
-		/// 	- One storage read to retrieve all current bids. O(B)
-		/// 	- One storage read to retrieve all current candidates. O(C)
-		/// - Storage Writes:
-		/// 	- One storage write to insert vouching status to the member. O(1)
-		/// 	- One storage mutate to add a new bid to the vector O(B) (TODO: possible optimization
-		///    w/ read)
-		/// 	- Up to one storage removal if bid.len() > MAX_BID_COUNT. O(1)
-		/// - Notable Computation:
-		/// 	- O(log M) search to check sender is a member.
-		/// 	- O(B + C + log M) search to check user is not already a part of society.
-		/// 	- O(log B) search to insert the new bid sorted.
-		/// - External Pallet Operations:
-		/// 	- One balance reserve operation. O(X)
-		/// 	- Up to one balance unreserve operation if bids.len() > MAX_BID_COUNT.
-		/// - Events:
-		/// 	- One event for vouch.
-		/// 	- Up to one event for AutoUnbid if bid.len() > MAX_BID_COUNT.
-		///
 		/// Total Complexity: O(M + B + C + logM + logB + X)
-		/// # </weight>
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
 		pub fn vouch(
 			origin: OriginFor<T>,
@@ -829,21 +906,21 @@ pub mod pallet {
 		) -> DispatchResult {
 			let voucher = ensure_signed(origin)?;
 			// Check user is not suspended.
-			ensure!(!<SuspendedCandidates<T, I>>::contains_key(&who), Error::<T, I>::Suspended);
-			ensure!(!<SuspendedMembers<T, I>>::contains_key(&who), Error::<T, I>::Suspended);
+			ensure!(!SuspendedCandidates::<T, I>::contains_key(&who), Error::<T, I>::Suspended);
+			ensure!(!SuspendedMembers::<T, I>::contains_key(&who), Error::<T, I>::Suspended);
 			// Check user is not a bid or candidate.
-			let bids = <Bids<T, I>>::get();
-			ensure!(!Self::is_bid(&bids, &who), Error::<T, I>::AlreadyBid);
-			let candidates = <Candidates<T, I>>::get();
+			let bids = Bids::<T, I>::get();
+			ensure!(!Self::has_bid(&bids, &who), Error::<T, I>::AlreadyBid);
+			let candidates = Candidates::<T, I>::get();
 			ensure!(!Self::is_candidate(&candidates, &who), Error::<T, I>::AlreadyCandidate);
 			// Check user is not already a member.
-			let members = <Members<T, I>>::get();
+			let members = Members::<T, I>::get();
 			ensure!(!Self::is_member(&members, &who), Error::<T, I>::AlreadyMember);
 			// Check sender can vouch.
 			ensure!(Self::is_member(&members, &voucher), Error::<T, I>::NotMember);
-			ensure!(!<Vouching<T, I>>::contains_key(&voucher), Error::<T, I>::AlreadyVouching);
+			ensure!(!Vouching::<T, I>::contains_key(&voucher), Error::<T, I>::AlreadyVouching);
 
-			<Vouching<T, I>>::insert(&voucher, VouchingStatus::Vouching);
+			Vouching::<T, I>::insert(&voucher, VouchingStatus::Vouching);
 			Self::put_bid(bids, &who, value.clone(), BidKind::Vouch(voucher.clone(), tip));
 			Self::deposit_event(Event::<T, I>::Vouch {
 				candidate_id: who,
@@ -861,28 +938,21 @@ pub mod pallet {
 		/// Parameters:
 		/// - `pos`: Position in the `Bids` vector of the bid who should be unvouched.
 		///
-		/// # <weight>
 		/// Key: B (len of bids)
-		/// - One storage read O(1) to check the signer is a vouching member.
-		/// - One storage mutate to retrieve and update the bids. O(B)
-		/// - One vouching storage removal. O(1)
-		/// - One event.
-		///
 		/// Total Complexity: O(B)
-		/// # </weight>
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
 		pub fn unvouch(origin: OriginFor<T>, pos: u32) -> DispatchResult {
 			let voucher = ensure_signed(origin)?;
 			ensure!(
-				Self::vouching(&voucher) == Some(VouchingStatus::Vouching),
+				Vouching::<T, I>::get(&voucher) == Some(VouchingStatus::Vouching),
 				Error::<T, I>::NotVouching
 			);
 
 			let pos = pos as usize;
-			<Bids<T, I>>::mutate(|b| {
+			Bids::<T, I>::mutate(|b| {
 				if pos < b.len() {
 					b[pos].kind.check_voucher(&voucher)?;
-					<Vouching<T, I>>::remove(&voucher);
+					Vouching::<T, I>::remove(&voucher);
 					let who = b.remove(pos).who;
 					Self::deposit_event(Event::<T, I>::Unvouch { candidate: who });
 					Ok(())
@@ -901,16 +971,8 @@ pub mod pallet {
 		/// - `approve`: A boolean which says if the candidate should be approved (`true`) or
 		///   rejected (`false`).
 		///
-		/// # <weight>
 		/// Key: C (len of candidates), M (len of members)
-		/// - One storage read O(M) and O(log M) search to check user is a member.
-		/// - One account lookup.
-		/// - One storage read O(C) and O(C) search to check that user is a candidate.
-		/// - One storage write to add vote to votes. O(1)
-		/// - One event.
-		///
 		/// Total Complexity: O(M + logM + C)
-		/// # </weight>
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
 		pub fn vote(
 			origin: OriginFor<T>,
@@ -919,14 +981,24 @@ pub mod pallet {
 		) -> DispatchResult {
 			let voter = ensure_signed(origin)?;
 			let candidate = T::Lookup::lookup(candidate)?;
-			let candidates = <Candidates<T, I>>::get();
-			ensure!(Self::is_candidate(&candidates, &candidate), Error::<T, I>::NotCandidate);
-			let members = <Members<T, I>>::get();
-			ensure!(Self::is_member(&members, &voter), Error::<T, I>::NotMember);
 
-			let vote = if approve { Vote::Approve } else { Vote::Reject };
-			<Votes<T, I>>::insert(&candidate, &voter, vote);
+			let mut candidacy = Candidate::<T, I>::get(candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			let record = Membership::<T, I>::get(&voter).ok_or(Error::<T, I>::NotMember)?;
 
+			// remove the old vote from the count, if there was one.
+			match Votes::<T, I>::get(&candidate, &voter) {
+				Some(Vote { approve: true, weight }) => candidacy.approves.saturating_reduce(weight),
+				Some(Vote { approve: false, weight }) => candidacy.rejects.saturating_reduce(weight),
+				_ => {},
+			}
+			let weight_root = record.rank + 1;
+			let weight = weight_root * weight_root;
+			match approve {
+				true => candidacy.approves.saturating_accrue(1),
+				false => candidacy.rejects.saturating_accrue(1),
+			}
+			Votes::<T, I>::insert(&candidate, &voter, Vote { approve, weight });
+			Candidate::<T, I>::insert(&candidate, &candidacy);
 			Self::deposit_event(Event::<T, I>::Vote { candidate, voter, vote: approve });
 			Ok(())
 		}
@@ -939,22 +1011,17 @@ pub mod pallet {
 		/// - `approve`: A boolean which says if the candidate should be
 		/// approved (`true`) or rejected (`false`).
 		///
-		/// # <weight>
-		/// - Key: M (len of members)
-		/// - One storage read O(M) and O(log M) search to check user is a member.
-		/// - One storage write to add vote to votes. O(1)
-		/// - One event.
-		///
+		/// Key: M (len of members)
 		/// Total Complexity: O(M + logM)
 		/// # </weight>
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
 		pub fn defender_vote(origin: OriginFor<T>, approve: bool) -> DispatchResult {
 			let voter = ensure_signed(origin)?;
-			let members = <Members<T, I>>::get();
+			let members = Members::<T, I>::get();
 			ensure!(Self::is_member(&members, &voter), Error::<T, I>::NotMember);
 
 			let vote = if approve { Vote::Approve } else { Vote::Reject };
-			<DefenderVotes<T, I>>::insert(&voter, vote);
+			DefenderVotes::<T, I>::insert(&voter, vote);
 
 			Self::deposit_event(Event::<T, I>::DefenderVote { voter, vote: approve });
 			Ok(())
@@ -971,39 +1038,39 @@ pub mod pallet {
 		/// The dispatch origin for this call must be _Signed_ and a member with
 		/// payouts remaining.
 		///
-		/// # <weight>
 		/// Key: M (len of members), P (number of payouts for a particular member)
-		/// - One storage read O(M) and O(log M) search to check signer is a member.
-		/// - One storage read O(P) to get all payouts for a member.
-		/// - One storage read O(1) to get the current block number.
-		/// - One currency transfer call. O(X)
-		/// - One storage write or removal to update the member's payouts. O(P)
-		///
 		/// Total Complexity: O(M + logM + P + X)
-		/// # </weight>
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
 		pub fn payout(origin: OriginFor<T>) -> DispatchResult {
 			let who = ensure_signed(origin)?;
+			let mut record = Membership::<T, I>::get(&who).ok_or(Error::<T, I>::NotMember)?;
 
-			let members = <Members<T, I>>::get();
-			ensure!(Self::is_member(&members, &who), Error::<T, I>::NotMember);
-
-			let mut payouts = <Payouts<T, I>>::get(&who);
-			if let Some((when, amount)) = payouts.first() {
+			if let Some((when, amount)) = record.payouts.first() {
 				if when <= &<frame_system::Pallet<T>>::block_number() {
+					record.paid = record.paid.checked_add(amount).ok_or(Overflow)?;
 					T::Currency::transfer(&Self::payouts(), &who, *amount, AllowDeath)?;
-					payouts.remove(0);
-					if payouts.is_empty() {
-						<Payouts<T, I>>::remove(&who);
-					} else {
-						<Payouts<T, I>>::insert(&who, payouts);
-					}
+					record.payouts.remove(0);
+					Membership::<T, I>::insert(&who, record);
 					return Ok(())
 				}
 			}
 			Err(Error::<T, I>::NoPayout)?
 		}
 
+		/// Repay the payment previously given to the member with the signed origin, and elevate
+		/// them from rank 0 to rank 1.
+		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		pub fn repay(origin: OriginFor<T>) -> DispatchResult {
+			todo!()
+		}
+
+		/// Remove the payment owed to the member with the signed origin, and elevate them from
+		/// rank 0 to rank 1.
+		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		pub fn waive(origin: OriginFor<T>) -> DispatchResult {
+			todo!()
+		}
+
 		/// Found the society.
 		///
 		/// This is done as a discrete action in order to allow for the
@@ -1016,13 +1083,7 @@ pub mod pallet {
 		/// - `max_members` - The initial max number of members for the society.
 		/// - `rules` - The rules of this society concerning membership.
 		///
-		/// # <weight>
-		/// - Two storage mutates to set `Head` and `Founder`. O(1)
-		/// - One storage write to add the first member to society. O(1)
-		/// - One event.
-		///
-		/// Total Complexity: O(1)
-		/// # </weight>
+		/// Complexity: O(1)
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
 		pub fn found(
 			origin: OriginFor<T>,
@@ -1031,13 +1092,13 @@ pub mod pallet {
 			rules: Vec<u8>,
 		) -> DispatchResult {
 			T::FounderSetOrigin::ensure_origin(origin)?;
-			ensure!(!<Head<T, I>>::exists(), Error::<T, I>::AlreadyFounded);
+			ensure!(!Head::<T, I>::exists(), Error::<T, I>::AlreadyFounded);
 			ensure!(max_members > 1, Error::<T, I>::MaxMembers);
 			// This should never fail in the context of this function...
-			<MaxMembers<T, I>>::put(max_members);
-			Self::add_member(&founder)?;
-			<Head<T, I>>::put(&founder);
-			<Founder<T, I>>::put(&founder);
+			MaxMembers::<T, I>::put(max_members);
+			Self::add_member(&founder, 1, BoundedVec::new())?;
+			Head::<T, I>::put(&founder);
+			Founder::<T, I>::put(&founder);
 			Rules::<T, I>::put(T::Hashing::hash(&rules));
 			Self::deposit_event(Event::<T, I>::Founded { founder });
 			Ok(())
@@ -1063,10 +1124,15 @@ pub mod pallet {
 			ensure!(Head::<T, I>::get() == Some(founder.clone()), Error::<T, I>::NotHead);
 
 			Members::<T, I>::kill();
+			MemberCount::<T, I>::kill();
+			MemberByIndex::<T, I>::remove_all(None);
+			Membership::<T, I>::remove_all(None);
+			Votes::<T, I>::remove_all(None);
 			Head::<T, I>::kill();
 			Founder::<T, I>::kill();
 			Rules::<T, I>::kill();
 			Candidates::<T, I>::kill();
+			Candidate::<T, I>::remove_all(None);
 			SuspendedCandidates::<T, I>::remove_all(None);
 			Self::deposit_event(Event::<T, I>::Unfounded { founder });
 			Ok(())
@@ -1080,182 +1146,114 @@ pub mod pallet {
 		/// If a suspended member is rejected, remove all associated storage items, including
 		/// their payouts, and remove any vouched bids they currently have.
 		///
-		/// The dispatch origin for this call must be from the _SuspensionJudgementOrigin_.
+		/// The dispatch origin for this call must be from the _JudgementOrigin_.
 		///
 		/// Parameters:
 		/// - `who` - The suspended member to be judged.
 		/// - `forgive` - A boolean representing whether the suspension judgement origin forgives
 		///   (`true`) or rejects (`false`) a suspended member.
 		///
-		/// # <weight>
 		/// Key: B (len of bids), M (len of members)
-		/// - One storage read to check `who` is a suspended member. O(1)
-		/// - Up to one storage write O(M) with O(log M) binary search to add a member back to
-		///   society.
-		/// - Up to 3 storage removals O(1) to clean up a removed member.
-		/// - Up to one storage write O(B) with O(B) search to remove vouched bid from bids.
-		/// - Up to one additional event if unvouch takes place.
-		/// - One storage removal. O(1)
-		/// - One event for the judgement.
-		///
 		/// Total Complexity: O(M + logM + B)
-		/// # </weight>
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
 		pub fn judge_suspended_member(
 			origin: OriginFor<T>,
 			who: T::AccountId,
 			forgive: bool,
 		) -> DispatchResult {
-			T::SuspensionJudgementOrigin::ensure_origin(origin)?;
-			ensure!(<SuspendedMembers<T, I>>::contains_key(&who), Error::<T, I>::NotSuspended);
+			T::JudgementOrigin::ensure_origin(origin)?;
+			let record = SuspendedMembers::<T, I>::get(&who).ok_or(Error::<T, I>::NotSuspended)?;
 
 			if forgive {
 				// Try to add member back to society. Can fail with `MaxMembers` limit.
-				Self::add_member(&who)?;
+				Self::reinstate_member(&who, record.rank, record.payouts)?;
 			} else {
-				// Cancel a suspended member's membership, remove their payouts.
-				<Payouts<T, I>>::remove(&who);
-				<Strikes<T, I>>::remove(&who);
-				// Remove their vouching status, potentially unbanning them in the future.
-				if <Vouching<T, I>>::take(&who) == Some(VouchingStatus::Vouching) {
-					// Try to remove their bid if they are vouching.
-					// If their vouch is already a candidate, do nothing.
-					<Bids<T, I>>::mutate(|bids|
-						// Try to find the matching bid
-						if let Some(pos) = bids.iter().position(|b| b.kind.check_voucher(&who).is_ok()) {
-							// Remove the bid, and emit an event
-							let vouched = bids.remove(pos).who;
-							Self::deposit_event(Event::<T, I>::Unvouch { candidate: vouched });
-						}
-					);
-				}
+				Self::unreserve_payout(record.payouts.into_iter().map(|x| x.1).sum());
 			}
 
-			<SuspendedMembers<T, I>>::remove(&who);
+			SuspendedMembers::<T, I>::remove(&who);
 			Self::deposit_event(Event::<T, I>::SuspendedMemberJudgement { who, judged: forgive });
 			Ok(())
 		}
 
-		/// Allow suspended judgement origin to make judgement on a suspended candidate.
-		///
-		/// If the judgement is `Approve`, we add them to society as a member with the appropriate
-		/// payment for joining society.
-		///
-		/// If the judgement is `Reject`, we either slash the deposit of the bid, giving it back
-		/// to the society treasury, or we ban the voucher from vouching again.
-		///
-		/// If the judgement is `Rebid`, we put the candidate back in the bid pool and let them go
-		/// through the induction process again.
-		///
-		/// The dispatch origin for this call must be from the _SuspensionJudgementOrigin_.
-		///
-		/// Parameters:
-		/// - `who` - The suspended candidate to be judged.
-		/// - `judgement` - `Approve`, `Reject`, or `Rebid`.
-		///
-		/// # <weight>
-		/// Key: B (len of bids), M (len of members), X (balance action)
-		/// - One storage read to check `who` is a suspended candidate.
-		/// - One storage removal of the suspended candidate.
-		/// - Approve Logic
-		/// 	- One storage read to get the available pot to pay users with. O(1)
-		/// 	- One storage write to update the available pot. O(1)
-		/// 	- One storage read to get the current block number. O(1)
-		/// 	- One storage read to get all members. O(M)
-		/// 	- Up to one unreserve currency action.
-		/// 	- Up to two new storage writes to payouts.
-		/// 	- Up to one storage write with O(log M) binary search to add a member to society.
-		/// - Reject Logic
-		/// 	- Up to one repatriate reserved currency action. O(X)
-		/// 	- Up to one storage write to ban the vouching member from vouching again.
-		/// - Rebid Logic
-		/// 	- Storage mutate with O(log B) binary search to place the user back into bids.
-		/// - Up to one additional event if unvouch takes place.
-		/// - One storage removal.
-		/// - One event for the judgement.
-		///
-		/// Total Complexity: O(M + logM + B + X)
-		/// # </weight>
-		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
-		pub fn judge_suspended_candidate(
-			origin: OriginFor<T>,
-			who: T::AccountId,
-			judgement: Judgement,
-		) -> DispatchResult {
-			T::SuspensionJudgementOrigin::ensure_origin(origin)?;
-			if let Some((value, kind)) = <SuspendedCandidates<T, I>>::get(&who) {
-				match judgement {
-					Judgement::Approve => {
-						// Suspension Judgement origin has approved this candidate
-						// Make sure we can pay them
-						let pot = Self::pot();
-						ensure!(pot >= value, Error::<T, I>::InsufficientPot);
-						// Try to add user as a member! Can fail with `MaxMember` limit.
-						Self::add_member(&who)?;
-						// Reduce next pot by payout
-						<Pot<T, I>>::put(pot - value);
-						// Add payout for new candidate
-						let maturity = <frame_system::Pallet<T>>::block_number() +
-							Self::lock_duration(Self::members().len() as u32);
-						Self::pay_accepted_candidate(&who, value, kind, maturity);
-					},
-					Judgement::Reject => {
-						// Founder has rejected this candidate
-						match kind {
-							BidKind::Deposit(deposit) => {
-								// Slash deposit and move it to the society account
-								let res = T::Currency::repatriate_reserved(
-									&who,
-									&Self::account_id(),
-									deposit,
-									BalanceStatus::Free,
-								);
-								debug_assert!(res.is_ok());
-							},
-							BidKind::Vouch(voucher, _) => {
-								// Ban the voucher from vouching again
-								<Vouching<T, I>>::insert(&voucher, VouchingStatus::Banned);
-							},
-						}
-					},
-					Judgement::Rebid => {
-						// Founder has taken no judgement, and candidate is placed back into the
-						// pool.
-						let bids = <Bids<T, I>>::get();
-						Self::put_bid(bids, &who, value, kind);
-					},
-				}
-
-				// Remove suspended candidate
-				<SuspendedCandidates<T, I>>::remove(who);
-			} else {
-				Err(Error::<T, I>::NotSuspended)?
-			}
-			Ok(())
-		}
-
 		/// Allows root origin to change the maximum number of members in society.
-		/// Max membership count must be greater than 1.
+		/// New max membership count must be no less than the current number of members.
 		///
-		/// The dispatch origin for this call must be from _ROOT_.
+		/// The dispatch origin for this call must be Root.
 		///
 		/// Parameters:
 		/// - `max` - The maximum number of members for the society.
 		///
-		/// # <weight>
-		/// - One storage write to update the max. O(1)
-		/// - One event.
-		///
 		/// Total Complexity: O(1)
-		/// # </weight>
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
 		pub fn set_max_members(origin: OriginFor<T>, max: u32) -> DispatchResult {
-			ensure_root(origin)?;
-			ensure!(max > 1, Error::<T, I>::MaxMembers);
+			T::AdminOrigin::ensure_origin(origin)?;
+			ensure!(max >= MemberCount::<T, I>::get(), Error::<T, I>::MaxMembers);
 			MaxMembers::<T, I>::put(max);
 			Self::deposit_event(Event::<T, I>::NewMaxMembers { max });
 			Ok(())
 		}
+
+		/// Transform an approved candidate into a member. Callable only by the
+		/// the candidate, and only after the period for voting has ended.
+		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		pub fn claim_membership(origin: OriginFor<T>) -> DispatchResult {
+			let candidate = ensure_signed(origin)?;
+			let candidacy = Candidate::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			ensure!(candidacy.approvals > candidacy.rejections, Error::<T, I>::NotApproved);
+			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
+			Self::induct_member(candidate, candidacy, 0)
+		}
+
+		/// Transform an approved candidate into a member. Callable only by the
+		/// `JudgementOrigin` and only after the period for voting has ended.
+		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		pub fn force_membership(origin: OriginFor<T>, candidate: T::AccountId) -> DispatchResult {
+			T::JudgementOrigin::ensure_origin(origin)?;
+			let candidacy = Candidate::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
+			Self::induct_member(candidate, candidacy, 0)
+		}
+
+		/// Remove the candidate's application from the society. Callable only by the
+		/// `JudgementOrigin` and the candidate, and only after the period for voting has ended.
+		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		pub fn kick_candidate(origin: OriginFor<T>, candidate: T::AccountId) -> DispatchResult {
+			T::JudgementOrigin::ensure_origin(origin)?;
+			let candidacy = Candidate::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
+			Self::check_skeptic(&candidate, &candidacy);
+			Votes::<T, I>::remove_prefix(&candidate, None);
+			Candidate::<T, I>::remove(&candidate);
+			Ok(())
+		}
+
+		/// Remove the candidate's failed application from the society. Callable only by the
+		/// the candidate, and only after the period for voting has ended.
+		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		pub fn resign_candidate(origin: OriginFor<T>) -> DispatchResult {
+			let candidate = ensure_signed(origin)?;
+			let candidacy = Candidate::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			ensure!(candidacy.approvals <= candidacy.rejections, Error::<T, I>::Approved);
+			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
+			Self::check_skeptic(&candidate, &candidacy);
+			Votes::<T, I>::remove_prefix(&candidate, None);
+			Candidate::<T, I>::remove(&candidate);
+			Ok(())
+		}
+
+		/// Remove a `candidate`'s failed application from the society. Callable by any
+		/// signed origin but only after the subsequent period for voting has ended.
+		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		pub fn drop_candidate(origin: OriginFor<T>, candidate: T::AccountId) -> DispatchResult {
+			ensure_signed(origin)?;
+			let candidacy = Candidate::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			ensure!(candidacy.approvals <= candidacy.rejections, Error::<T, I>::Approved);
+			ensure!(RoundCount::<T, I>::get() > candidacy.round + 1, Error::<T, I>::TooEarly);
+			Votes::<T, I>::remove_prefix(&candidate, None);
+			Candidate::<T, I>::remove(&candidate);
+			Ok(())
+		}
 	}
 }
 
@@ -1287,363 +1285,403 @@ fn pick_item<'a, R: RngCore, T>(rng: &mut R, items: &'a [T]) -> Option<&'a T> {
 }
 
 /// Pick a new PRN, in the range [0, `max`] (inclusive).
-fn pick_usize<R: RngCore>(rng: &mut R, max: usize) -> usize {
+fn pick_usize(rng: &mut impl RngCore, max: usize) -> usize {
 	(rng.next_u32() % (max as u32 + 1)) as usize
 }
 
+struct InputFromRng<'a, T>(&'a mut T);
+impl<'a, T: RngCore> codec::Input for InputFromRng<'a, T> {
+	fn remaining_len(&mut self) -> Result<Option<usize>, Error> {
+		return Ok(None)
+	}
+
+	fn read(&mut self, into: &mut [u8]) -> Result<(), Error> {
+		self.0.fill_bytes(into);
+		Ok(())
+	}
+}
+
+pub enum Period<BlockNumber> {
+	Voting { elapsed: BlockNumber, more: BlockNumber },
+	Claim { elapsed: BlockNumber, more: BlockNumber },
+}
+
 impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	/// Get the period we are currently in.
+	fn period() -> Period<T::BlockNumber> {
+		let claim_period = T::ClaimPeriod::get();
+		let voting_period = T::VotingPeriod::get();
+		let rotation_period = voting_period + claim_period;
+		let now = <T as frame_system::Config>::block_number();
+		let phase = now % rotation_period;
+		if phase < voting_period {
+			Period::Voting { elapsed: phase, more: voting_period - phase }
+		} else {
+			Period::Claim { elapsed: phase - voting_period, more: rotation_period - phase }
+		}
+	}
+
+	/// Returns true if the given `target_round` is still in its initial voting phase.
+	fn in_progress(target_round: RoundIndex) -> bool {
+		let round = RoundCount::<T, I>::get();
+		target_round == round && matches!(Self::period(), Period::Voting {..})
+	}
+
+	fn check_skeptic(candidate: &T::AccountId, candidacy: &Candidacy<T::AccountId, BalanceOf<T>>) {
+		if RoundCount::<T, I>::get() != candidacy.round { return }
+		// We expect the skeptic to have voted.
+		let skeptic = Skeptic::<T, I>::get();
+		let maybe_vote = Votes::<T, I>::get(&candidate, &skeptic);
+		let approved = candidacy.approvals > candidacy.rejections;
+		let rejected = candidacy.rejections > candidacy.approvals;
+		match (maybe_vote, approved, rejected) {
+			(None, _, _) | (Some(false), true, false) | (Some(true), false, true) => {
+				// Can't do much if the punishment doesn't work out.
+				let _ = Self::strike_member(&skeptic);
+			},
+			_ => {},
+		}
+	}
+
+	/// End the current challenge period and start a new one.
+	fn rotate_challenge(rng: &mut impl RngCore) {
+		// TODO.
+		// End current defender rotation
+		if let Some((defender, skeptic, approvals, rejections)) = Defending::<T, I>::get() {
+			if rejections > approvals {
+				// Member has failed the challenge
+				Self::suspend_member(&defender);
+			}
+
+			// TODO: check skeptic voted and that their vote was with the majority. Slash if not.
+
+			// Clean up all votes.
+			DefenderVotes::<T, I>::remove_all(None);
+		}
+
+		// Avoid challenging if there's only two members since we never challenge the Head or
+		// the Founder.
+		if MemberCount::<T, I>::get() > 2 {
+			let defender = Self::pick_defendent(&mut rng).expect("exited if members empty; qed");
+			let skeptic = Self::pick_member_except(&mut rng, &defender).expect("exited if members empty; qed");
+			Self::deposit_event(Event::<T, I>::Challenged { member: defender.clone() });
+			Defending::<T, I>::put((defender, skeptic, 0, 0));
+		} else {
+			Defending::<T, I>::kill();
+		}
+	}
+
+	/// End the current intake period and begin a new one.
+	///
+	/// ---------------------------------------------
+	///  #10  || #11           _              || #12
+	///       || Voting        | Claiming     ||
+	/// ---------------------------------------------
+	fn rotate_intake(rng: &mut impl RngCore) {
+		// We assume there's at least one member or this logic won't work.
+		let member_count = MemberCount::get();
+		if member_count < 1 {
+			return
+		}
+		let maybe_head = NextHead::<T, I>::take();
+		if let Some(head) = maybe_head {
+			Head::<T, I>::put(head);
+		}
+
+		// Bump the pot by at most `PeriodSpend`, but less if there's not very much left in our
+		// account.
+		let mut pot = Pot::<T, I>::get();
+		let unaccounted = T::Currency::free_balance(&Self::account_id()).saturating_sub(pot);
+		pot.saturating_accrue(T::PeriodSpend::get().min(unaccounted / 2u8.into()));
+		Pot::<T, I>::put(&pot);
+
+		// Bump round and create the new intake.
+		let mut round_count = RoundCount::<T, I>::get();
+		round_count.saturating_inc();
+		let candidate_count = Self::select_new_candidates(round_count, member_count, pot);
+		if candidate_count > 0 {
+			// Select a member at random and make them the skeptic for this round.
+			let skeptic = Self::pick_member(&mut rng).expect("exited if members empty; qed");
+			Skeptic::<T, I>::put(skeptic);
+		}
+		RoundCount::<T, I>::put(round_count);
+	}
+
+	/// Remove a selection of bidding accounts such that the total bids is no greater than `Pot` and
+	/// the number of bids would not surpass `MaxMembers` if all were accepted. At most one bid may
+	/// be zero.
+	///
+	/// Candidates are inserted from each bidder.
+	///
+	/// The number of candidates inserted are returned.
+	pub fn select_new_candidates(
+		round: RoundIndex,
+		member_count: u32,
+		pot: BalanceOf<T, I>,
+	) -> usize {
+		let max_members = MaxMembers::<T, I>::get() as usize;
+
+		// Get the number of left-most bidders whose bids add up to less than `pot`.
+		let mut bids = Bids::<T, I>::get();
+		let mut max_selections: usize = (T::MaxCandidateIntake::get() as usize)
+			.min(max_members.saturating_sub(member_count))
+			.min(bids.len());
+
+		let mut selections = 0;
+		// A running total of the cost to onboard these bids
+		let mut total_cost: BalanceOf<T, I> = Zero::zero();
+
+		bids.retain(|bid| {
+			// We only accept a zero bid as the first selection.
+			total_cost.saturating_accrue(bid.value);
+			let accept = selections < max_selections
+				&& (!bid.value.is_zero() || selections == 0)
+				&& total_cost <= pot;
+			if accept {
+				let candidacy = Candidacy {
+					round,
+					kind: bid.kind,
+					bid: bid.value,
+					approvals: 0,
+					rejections: 0,
+				};
+				Candidate::<T, I>::insert(&bid.who, candidacy);
+				selections.saturating_inc();
+			}
+			!accept
+		});
+
+		// No need to reset Bids if we're not taking anything.
+		Bids::<T, I>::put(bids);
+	}
+
 	/// Puts a bid into storage ordered by smallest to largest value.
 	/// Allows a maximum of 1000 bids in queue, removing largest value people first.
-	fn put_bid(
-		mut bids: Vec<Bid<T::AccountId, BalanceOf<T, I>>>,
+	fn insert_bid(
+		bids: &mut BoundedVec<Bid<T::AccountId, BalanceOf<T, I>>, T::MaxBids>,
 		who: &T::AccountId,
 		value: BalanceOf<T, I>,
 		bid_kind: BidKind<T::AccountId, BalanceOf<T, I>>,
 	) {
-		const MAX_BID_COUNT: usize = 1000;
-
-		match bids.binary_search_by(|bid| bid.value.cmp(&value)) {
-			// Insert new elements after the existing ones. This ensures new bids
-			// with the same bid value are further down the list than existing ones.
-			Ok(pos) => {
-				let different_bid = bids
-					.iter()
-					// Easily extract the index we are on
-					.enumerate()
-					// Skip ahead to the suggested position
-					.skip(pos)
-					// Keep skipping ahead until the position changes
-					// Get the element when things changed
-					.find(|(_, x)| x.value > bids[pos].value);
-
-				// If the element is not at the end of the list, insert the new element
-				// in the spot.
-				if let Some((p, _)) = different_bid {
-					bids.insert(p, Bid { value, who: who.clone(), kind: bid_kind });
-				// If the element is at the end of the list, push the element on the end.
-				} else {
-					bids.push(Bid { value, who: who.clone(), kind: bid_kind });
-				}
-			},
-			Err(pos) => bids.insert(pos, Bid { value, who: who.clone(), kind: bid_kind }),
-		}
-		// Keep it reasonably small.
-		if bids.len() > MAX_BID_COUNT {
-			let Bid { who: popped, kind, .. } = bids.pop().expect("b.len() > 1000; qed");
-			match kind {
-				BidKind::Deposit(deposit) => {
-					let err_amount = T::Currency::unreserve(&popped, deposit);
-					debug_assert!(err_amount.is_zero());
-				},
-				BidKind::Vouch(voucher, _) => {
-					<Vouching<T, I>>::remove(&voucher);
-				},
-			}
-			Self::deposit_event(Event::<T, I>::AutoUnbid { candidate: popped });
+		let pos = bids.iter().position(|bid| bid.value > value).unwrap_or(bids.len());
+		let r = bids.force_insert_keep_left(pos, Bid { value, who: who.clone(), kind: bid_kind });
+		let maybe_discarded = r.err().or_else(|| r.ok());
+		if let Some(discarded) = maybe_discarded {
+			Self::clean_bid(&discarded);
+			Self::deposit_event(Event::<T, I>::AutoUnbid { candidate: discarded });
 		}
+	}
 
-		<Bids<T, I>>::put(bids);
+	/// Either unreserve the deposit or free up the vouching member.
+	///
+	/// In neither case can we do much if the action isn't completable, but there's
+	/// no reason that either should fail.
+	fn clean_bid(bid: &Bid<T::AccountId, BalanceOf<T, I>>) {
+		match &bid.kind {
+			BidKind::Deposit(deposit) => {
+				let err_amount = T::Currency::unreserve(&bid.who, *deposit);
+				debug_assert!(err_amount.is_zero());
+			},
+			BidKind::Vouch(voucher, _) => {
+				Vouching::<T, I>::remove(voucher);
+			},
+		}
 	}
 
-	/// Check a user is a bid.
-	fn is_bid(bids: &Vec<Bid<T::AccountId, BalanceOf<T, I>>>, who: &T::AccountId) -> bool {
+	/// Check a user has a bid.
+	fn has_bid(bids: &Vec<Bid<T::AccountId, BalanceOf<T, I>>>, who: &T::AccountId) -> bool {
 		// Bids are ordered by `value`, so we cannot binary search for a user.
 		bids.iter().any(|bid| bid.who == *who)
 	}
 
-	/// Check a user is a candidate.
-	fn is_candidate(
-		candidates: &Vec<Bid<T::AccountId, BalanceOf<T, I>>>,
-		who: &T::AccountId,
-	) -> bool {
-		// Looking up a candidate is the same as looking up a bid
-		Self::is_bid(candidates, who)
+	/// Add a member to the sorted members list. If the user is already a member, do nothing.
+	/// Can fail when `MaxMember` limit is reached, but in that case it has no side-effects.
+	///
+	/// Set the `payouts` for the member. NOTE: This *WILL NOT RESERVE THE FUNDS TO MAKE THE
+	/// PAYOUT*. Only set this to be non-empty if you already have the funds reserved in the Payouts
+	/// account.
+	///
+	/// NOTE: Generally you should not use this, and instead use `add_new_member` or
+	/// `reinstate_member`, whose names clearly match the desired intention.
+	fn insert_member(who: &T::AccountId, rank: Rank, payouts: PayoutsFor<T>) -> DispatchResult {
+		ensure!(MemberCount::get() < MaxMembers::<T, I>::get() as usize, Error::<T, I>::MaxMembers);
+		let index = MemberCount::<T, I>::mutate(|i| { i.saturating_accrue(1); *i - 1 });
+		let paid = Zero::zero();
+		let record = MemberRecord { rank, strikes: 0, vouching: None, paid, index, payouts };
+		Membership::<T, I>::insert(who, record);
+		MemberByIndex::<T, I>::insert(index, who);
+		Ok(())
 	}
 
-	/// Check a user is a member.
-	fn is_member(members: &Vec<T::AccountId>, who: &T::AccountId) -> bool {
-		members.binary_search(who).is_ok()
+	/// Add a member back to the sorted members list, setting their `rank` and `payouts`.
+	///
+	/// Can fail when `MaxMember` limit is reached, but in that case it has no side-effects.
+	///
+	/// The `payouts` value must be exactly as it was prior to suspension since no further funds
+	/// will be reserved.
+	fn reinstate_member(who: &T::AccountId, rank: Rank, payouts: PayoutsFor<T>) -> DispatchResult {
+		Self::insert_member(who, rank, payouts)
 	}
 
 	/// Add a member to the sorted members list. If the user is already a member, do nothing.
-	/// Can fail when `MaxMember` limit is reached, but has no side-effects.
-	fn add_member(who: &T::AccountId) -> DispatchResult {
-		let mut members = <Members<T, I>>::get();
-		ensure!(members.len() < MaxMembers::<T, I>::get() as usize, Error::<T, I>::MaxMembers);
-		match members.binary_search(who) {
-			// Add the new member
-			Err(i) => {
-				members.insert(i, who.clone());
-				T::MembershipChanged::change_members_sorted(&[who.clone()], &[], &members);
-				<Members<T, I>>::put(members);
-				Ok(())
-			},
-			// User is already a member, do nothing.
-			Ok(_) => Ok(()),
-		}
+	/// Can fail when `MaxMember` limit is reached, but in that case it has no side-effects.
+	fn add_new_member(who: &T::AccountId, rank: Rank) -> DispatchResult {
+		Self::insert_member(who, rank, Default::default())
 	}
 
-	/// Remove a member from the members list, except the Head.
-	///
-	/// NOTE: This does not correctly clean up a member from storage. It simply
-	/// removes them from the Members storage item.
-	pub fn remove_member(m: &T::AccountId) -> DispatchResult {
-		ensure!(Self::head() != Some(m.clone()), Error::<T, I>::Head);
-		ensure!(Self::founder() != Some(m.clone()), Error::<T, I>::Founder);
-
-		let mut members = <Members<T, I>>::get();
-		match members.binary_search(&m) {
-			Err(_) => Err(Error::<T, I>::NotMember)?,
-			Ok(i) => {
-				members.remove(i);
-				T::MembershipChanged::change_members_sorted(&[], &[m.clone()], &members[..]);
-				<Members<T, I>>::put(members);
-				Ok(())
-			},
+	/// Induct a new member into the set.
+	fn induct_member(
+		candidate: T::AccountId,
+		candidacy: Candidacy<T::AccountId, BalanceOf<T>>,
+		rank: Rank,
+	) -> DispatchResult {
+		Self::check_skeptic(&candidate, &candidacy);
+		Self::add_new_member(&candidate, 0)?;
+		let next_head = NextHead::<T, I>::get()
+			.filter(|old| old.round > candidacy.round
+				|| old.round == candidacy.round && old.bid < candidacy.bid
+			).unwrap_or_else(|| IntakeRecord { who: candidate.clone(), bid: candidacy.bid, round: candidacy.round });
+		NextHead::<T, I>::put(next_head);
+		let now = <frame_system::Pallet<T>>::block_number();
+		let maturity = now + Self::lock_duration(MemberCount::<T, I>::get());
+		Self::reward_bidder(&candidate, candidacy.bid, candidacy.kind, maturity);
+		Votes::<T, I>::remove_prefix(&candidate, None);
+		Candidate::<T, I>::remove(&candidate);
+		Ok(())
+	}
+
+	fn strike_member(who: &T::AccountId) -> DispatchResult {
+		let mut record = Membership::<T, I>::get(who).ok_or(NotMember)?;
+		record.strikes.saturating_inc();
+		if record.strikes >= T::GraceStrikes::get() {
+			// Too many strikes: slash the payout in half.
+			let total_payout = record.payouts.iter().map(|x| x.1).sum();
+			Self::slash_payout(who, total_payout / 2u32.into());
 		}
+		if record.strikes >= T::MaxStrikes::get() {
+			// Way too many strikes: suspend.
+			Self::suspend_member(who);
+		}
+		Ok(())
 	}
 
-	/// End the current period and begin a new one.
-	fn rotate_period(members: &mut Vec<T::AccountId>) {
-		let phrase = b"society_rotation";
-
-		let mut pot = <Pot<T, I>>::get();
-
-		// we'll need a random seed here.
-		// TODO: deal with randomness freshness
-		// https://github.com/paritytech/substrate/issues/8312
-		let (seed, _) = T::Randomness::random(phrase);
-		// seed needs to be guaranteed to be 32 bytes.
-		let seed = <[u8; 32]>::decode(&mut TrailingZeroInput::new(seed.as_ref()))
-			.expect("input is padded with zeroes; qed");
-		let mut rng = ChaChaRng::from_seed(seed);
-
-		// we assume there's at least one member or this logic won't work.
-		if !members.is_empty() {
-			let candidates = <Candidates<T, I>>::take();
-			// NOTE: This may cause member length to surpass `MaxMembers`, but results in no
-			// consensus critical issues or side-effects. This is auto-correcting as members fall
-			// out of society.
-			members.reserve(candidates.len());
-
-			let maturity = <frame_system::Pallet<T>>::block_number() +
-				Self::lock_duration(members.len() as u32);
-
-			let mut rewardees = Vec::new();
-			let mut total_approvals = 0;
-			let mut total_slash = <BalanceOf<T, I>>::zero();
-			let mut total_payouts = <BalanceOf<T, I>>::zero();
-
-			let accepted = candidates
-				.into_iter()
-				.filter_map(|Bid { value, who: candidate, kind }| {
-					let mut approval_count = 0;
-
-					// Creates a vector of (vote, member) for the given candidate
-					// and tallies total number of approve votes for that candidate.
-					let votes = members
-						.iter()
-						.filter_map(|m| <Votes<T, I>>::take(&candidate, m).map(|v| (v, m)))
-						.inspect(|&(v, _)| {
-							if v == Vote::Approve {
-								approval_count += 1
-							}
-						})
-						.collect::<Vec<_>>();
-
-					// Select one of the votes at random.
-					// Note that `Vote::Skeptical` and `Vote::Reject` both reject the candidate.
-					let is_accepted =
-						pick_item(&mut rng, &votes).map(|x| x.0) == Some(Vote::Approve);
-
-					let matching_vote = if is_accepted { Vote::Approve } else { Vote::Reject };
-
-					let bad_vote = |m: &T::AccountId| {
-						// Voter voted wrong way (or was just a lazy skeptic) then reduce their
-						// payout and increase their strikes. after MaxStrikes then they go into
-						// suspension.
-						let amount = Self::slash_payout(m, T::WrongSideDeduction::get());
-
-						let strikes = <Strikes<T, I>>::mutate(m, |s| {
-							*s += 1;
-							*s
-						});
-						if strikes >= T::MaxStrikes::get() {
-							Self::suspend_member(m);
-						}
-						amount
-					};
-
-					// Collect the voters who had a matching vote.
-					rewardees.extend(
-						votes
-							.into_iter()
-							.filter_map(|(v, m)| {
-								if v == matching_vote {
-									Some(m)
-								} else {
-									total_slash += bad_vote(m);
-									None
-								}
-							})
-							.cloned(),
+	/// Remove a member from the members list and return the candidacy.
+	///
+	/// If the member was vouching, then this will be reset. Any bidders that the member was
+	/// vouching for will be cancelled unless they are already selected as candidates (in which case
+	/// they will be able to stand).
+	///
+	/// If the member has existing payouts, they will be retained in the resultant `MemberRecord`
+	/// and the funds will remain reserved.
+	///
+	/// The Head and the Founder may never be removed.
+	pub fn remove_member(m: &T::AccountId) -> Result<MemberRecord, DispatchError> {
+		ensure!(Head::<T, I>::get().as_ref() != Some(m), Error::<T, I>::Head);
+		ensure!(Founder::<T, I>::get().as_ref() != Some(m), Error::<T, I>::Founder);
+		if let Some(record) = Membership::<T, I>::get(m) {
+			let index = record.index;
+			let last_index = MemberCount::<T, I>::mutate(|i| { i.saturating_reduce(1); *i });
+			if index != last_index {
+				// Move the member with the last index down to the index of the member to be removed.
+				if let Some(other) = MemberByIndex::<T, I>::get(last_index) {
+					MemberByIndex::<T, I>::insert(index, other);
+					Membership::<T, I>::mutate(other, |m_r|
+						if let Some(r) = m_r { r.index = index }
 					);
-
-					if is_accepted {
-						total_approvals += approval_count;
-						total_payouts += value;
-						members.push(candidate.clone());
-
-						Self::pay_accepted_candidate(&candidate, value, kind, maturity);
-
-						// We track here the total_approvals so that every candidate has a unique
-						// range of numbers from 0 to `total_approvals` with length `approval_count`
-						// so each candidate is proportionally represented when selecting a
-						// "primary" below.
-						Some((candidate, total_approvals, value))
-					} else {
-						// Suspend Candidate
-						<SuspendedCandidates<T, I>>::insert(&candidate, (value, kind));
-						Self::deposit_event(Event::<T, I>::CandidateSuspended { candidate });
-						None
-					}
-				})
-				.collect::<Vec<_>>();
-
-			// Clean up all votes.
-			<Votes<T, I>>::remove_all(None);
-
-			// Reward one of the voters who voted the right way.
-			if !total_slash.is_zero() {
-				if let Some(winner) = pick_item(&mut rng, &rewardees) {
-					// If we can't reward them, not much that can be done.
-					Self::bump_payout(winner, maturity, total_slash);
 				} else {
-					// Move the slashed amount back from payouts account to local treasury.
-					let res = T::Currency::transfer(
-						&Self::payouts(),
-						&Self::account_id(),
-						total_slash,
-						AllowDeath,
-					);
-					debug_assert!(res.is_ok());
+					debug_assert!(false, "ERROR: No member at the last index position?");
 				}
 			}
 
-			// Fund the total payouts from the local treasury.
-			if !total_payouts.is_zero() {
-				// remove payout from pot and shift needed funds to the payout account.
-				pot = pot.saturating_sub(total_payouts);
-
-				// this should never fail since we ensure we can afford the payouts in a previous
-				// block, but there's not much we can do to recover if it fails anyway.
-				let res = T::Currency::transfer(
-					&Self::account_id(),
-					&Self::payouts(),
-					total_payouts,
-					AllowDeath,
+			MemberByIndex::<T, I>::remove(last_index);
+			Membership::<T, I>::remove(m);
+			// Remove their vouching status, potentially unbanning them in the future.
+			if record.vouching.take() == Some(VouchingStatus::Vouching) {
+				// Try to remove their bid if they are vouching.
+				// If their vouch is already a candidate, do nothing.
+				Bids::<T, I>::mutate(|bids|
+					// Try to find the matching bid
+					if let Some(pos) = bids.iter().position(|b| b.kind.check_voucher(&who).is_ok()) {
+						// Remove the bid, and emit an event
+						let vouched = bids.remove(pos).who;
+						Self::deposit_event(Event::<T, I>::Unvouch { candidate: vouched });
+					}
 				);
-				debug_assert!(res.is_ok());
-			}
-
-			// if at least one candidate was accepted...
-			if !accepted.is_empty() {
-				// select one as primary, randomly chosen from the accepted, weighted by approvals.
-				// Choose a random number between 0 and `total_approvals`
-				let primary_point = pick_usize(&mut rng, total_approvals - 1);
-				// Find the zero bid or the user who falls on that point
-				let primary = accepted
-					.iter()
-					.find(|e| e.2.is_zero() || e.1 > primary_point)
-					.expect(
-						"e.1 of final item == total_approvals; \
-						worst case find will always return that item; qed",
-					)
-					.0
-					.clone();
-
-				let accounts = accepted.into_iter().map(|x| x.0).collect::<Vec<_>>();
-
-				// Then write everything back out, signal the changed membership and leave an event.
-				members.sort();
-				// NOTE: This may cause member length to surpass `MaxMembers`, but results in no
-				// consensus critical issues or side-effects. This is auto-correcting as members
-				// fall out of society.
-				<Members<T, I>>::put(&members[..]);
-				<Head<T, I>>::put(&primary);
-
-				T::MembershipChanged::change_members_sorted(&accounts, &[], &members);
-				Self::deposit_event(Event::<T, I>::Inducted { primary, candidates: accounts });
 			}
-
-			// Bump the pot by at most PeriodSpend, but less if there's not very much left in our
-			// account.
-			let unaccounted = T::Currency::free_balance(&Self::account_id()).saturating_sub(pot);
-			pot += T::PeriodSpend::get().min(unaccounted / 2u8.into());
-
-			<Pot<T, I>>::put(&pot);
+			Ok(record)
+		} else {
+			Err(Error::<T, I>::NotMember.into())
 		}
+	}
 
-		// Setup the candidates for the new intake
-		let candidates = Self::take_selected(members.len(), pot);
-		<Candidates<T, I>>::put(&candidates);
-
-		// Select sqrt(n) random members from the society and make them skeptics.
-		let pick_member =
-			|_| pick_item(&mut rng, &members[..]).expect("exited if members empty; qed");
-		for skeptic in (0..members.len().integer_sqrt()).map(pick_member) {
-			for Bid { who: c, .. } in candidates.iter() {
-				<Votes<T, I>>::insert(c, skeptic, Vote::Skeptic);
-			}
+	/// Remove a member from the members set and add them to the suspended members.
+	///
+	/// If the member was vouching, then this will be reset. Any bidders that the member was
+	/// vouching for will be cancelled unless they are already selected as candidates (in which case
+	/// they will be able to stand).
+	fn suspend_member(who: &T::AccountId) {
+		if let Ok(record) = Self::remove_member(&who) {
+			SuspendedMembers::<T, I>::insert(who, record);
+			Self::deposit_event(Event::<T, I>::MemberSuspended { member: who.clone() });
 		}
 	}
 
-	/// Attempt to slash the payout of some member. Return the total amount that was deducted.
-	fn slash_payout(who: &T::AccountId, value: BalanceOf<T, I>) -> BalanceOf<T, I> {
-		let mut rest = value;
-		let mut payouts = <Payouts<T, I>>::get(who);
-		if !payouts.is_empty() {
-			let mut dropped = 0;
-			for (_, amount) in payouts.iter_mut() {
-				if let Some(new_rest) = rest.checked_sub(&amount) {
-					// not yet totally slashed after this one; drop it completely.
-					rest = new_rest;
-					dropped += 1;
-				} else {
-					// whole slash is accounted for.
-					*amount -= rest;
-					rest = Zero::zero();
-					break
-				}
-			}
-			<Payouts<T, I>>::insert(who, &payouts[dropped..]);
+	/// Select a member at random, given the RNG `rng`.
+	///
+	/// If no members exist (or the state is inconsistent), then `None` may be returned.
+	fn pick_member(rng: &mut impl RngCore) -> Option<T::AccountId> {
+		let member_count = MemberCount::get();
+		if member_count == 0 {
+			return None
 		}
-		value - rest
+		let random_index = rng.next_u32() % member_count;
+		MemberByIndex::<T, I>::get(random_index)
 	}
 
-	/// Bump the payout amount of `who`, to be unlocked at the given block number.
-	fn bump_payout(who: &T::AccountId, when: T::BlockNumber, value: BalanceOf<T, I>) {
-		if !value.is_zero() {
-			<Payouts<T, I>>::mutate(who, |payouts| {
-				match payouts.binary_search_by_key(&when, |x| x.0) {
-					Ok(index) => payouts[index].1 += value,
-					Err(index) => payouts.insert(index, (when, value)),
-				}
-			});
+	/// Select a member at random except `exception`, given the RNG `rng`.
+	///
+	/// If `exception` is the only member (or the state is inconsistent), then `None` may be returned.
+	fn pick_member_except(rng: &mut impl RngCore, exception: &T::AccountId) -> Option<T::AccountId> {
+		let member_count = MemberCount::get();
+		if member_count <= 1 {
+			return None
+		}
+		let random_index = rng.next_u32() % (member_count - 1);
+		let pick = MemberByIndex::<T, I>::get(random_index);
+		if pick.as_ref() == Some(exception) {
+			MemberByIndex::<T, I>::get(member_count - 1)
+		} else {
+			pick
 		}
 	}
 
-	/// Suspend a user, removing them from the member list.
-	fn suspend_member(who: &T::AccountId) {
-		if Self::remove_member(&who).is_ok() {
-			<SuspendedMembers<T, I>>::insert(who, true);
-			<Strikes<T, I>>::remove(who);
-			Self::deposit_event(Event::<T, I>::MemberSuspended { member: who.clone() });
+	/// Select a member who is able to defend at random, given the RNG `rng`.
+	///
+	/// If only the Founder and Head members exist (or the state is inconsistent), then `None`
+	/// may be returned.
+	fn pick_defendent(rng: &mut impl RngCore) -> Option<T::AccountId> {
+		let member_count = MemberCount::get();
+		if member_count <= 2 {
+			return None
+		}
+		// Founder is always at index 0, so we should never pick that one.
+		// Head will typically but not always be the highest index. We assume it is for now and
+		// fix it up later if not.
+		let head = Head::<T, I>::get();
+		let pickable_count = member_count - if head.is_some() { 2 } else { 1 };
+		let random_index = rng.next_u32() % pickable_count + 1;
+		let pick = MemberByIndex::<T, I>::get(random_index);
+		if pick == head && head.is_some() {
+			// Turns out that head was not the last index since we managed to pick it. Exchange our
+			// pick for the last index.
+			MemberByIndex::<T, I>::get(member_count - 1)
+		} else {
+			pick
 		}
 	}
 
 	/// Pay an accepted candidate their bid value.
-	fn pay_accepted_candidate(
+	fn reward_bidder(
 		candidate: &T::AccountId,
 		value: BalanceOf<T, I>,
 		kind: BidKind<T::AccountId, BalanceOf<T, I>>,
@@ -1660,7 +1698,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 			BidKind::Vouch(voucher, tip) => {
 				// Check that the voucher is still vouching, else some other logic may have removed
 				// their status.
-				if <Vouching<T, I>>::take(&voucher) == Some(VouchingStatus::Vouching) {
+				if Vouching::<T, I>::take(&voucher) == Some(VouchingStatus::Vouching) {
 					// In the case that a vouched-for bid is accepted we unset the
 					// vouching status and transfer the tip over to the voucher.
 					Self::bump_payout(&voucher, maturity, tip.min(value));
@@ -1674,53 +1712,80 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		Self::bump_payout(candidate, maturity, value);
 	}
 
-	/// End the current challenge period and start a new one.
-	fn rotate_challenge(members: &mut Vec<T::AccountId>) {
-		// Assume there are members, else don't run this logic.
-		if !members.is_empty() {
-			// End current defender rotation
-			if let Some(defender) = Self::defender() {
-				let mut approval_count = 0;
-				let mut rejection_count = 0;
-				// Tallies total number of approve and reject votes for the defender.
-				members.iter().filter_map(|m| <DefenderVotes<T, I>>::take(m)).for_each(
-					|v| match v {
-						Vote::Approve => approval_count += 1,
-						_ => rejection_count += 1,
-					},
-				);
-
-				if approval_count <= rejection_count {
-					// User has failed the challenge
-					Self::suspend_member(&defender);
-					*members = Self::members();
+	/// Bump the payout amount of `who`, to be unlocked at the given block number.
+	///
+	/// If it the caller's duty to ensure that `who` is already a member. This does nothing if `who`
+	/// is not a member or if `value` is zero.
+	fn bump_payout(who: &T::AccountId, when: T::BlockNumber, value: BalanceOf<T, I>) {
+		if !value.is_zero() {
+			Membership::<T, I>::mutate(who, |maybe_record| if let Some(record) = maybe_record {
+				if record.rank == 0 {
+					// Members of rank 1 never get payouts.
+					match record.payouts.binary_search_by_key(&when, |x| x.0) {
+						Ok(index) => record.payouts[index].1.saturating_accrue(value),
+						Err(index) => record.payouts.insert(index, (when, value)),
+					}
 				}
+			});
+			Self::reserve_payout(value);
+		}
+	}
 
-				// Clean up all votes.
-				<DefenderVotes<T, I>>::remove_all(None);
-			}
-
-			// Avoid challenging if there's only two members since we never challenge the Head or
-			// the Founder.
-			if members.len() > 2 {
-				// Start a new defender rotation
-				let phrase = b"society_challenge";
-				// we'll need a random seed here.
-				// TODO: deal with randomness freshness
-				// https://github.com/paritytech/substrate/issues/8312
-				let (seed, _) = T::Randomness::random(phrase);
-				// seed needs to be guaranteed to be 32 bytes.
-				let seed = <[u8; 32]>::decode(&mut TrailingZeroInput::new(seed.as_ref()))
-					.expect("input is padded with zeroes; qed");
-				let mut rng = ChaChaRng::from_seed(seed);
-				let chosen = pick_item(&mut rng, &members[1..members.len() - 1])
-					.expect("exited if members empty; qed");
-				<Defender<T, I>>::put(&chosen);
-				Self::deposit_event(Event::<T, I>::Challenged { member: chosen.clone() });
+	/// Attempt to slash the payout of some member. Return the total amount that was deducted.
+	fn slash_payout(who: &T::AccountId, value: BalanceOf<T, I>) -> BalanceOf<T, I> {
+		let mut record = match Membership::<T, I>::get(who) {
+			Some(record) => record,
+			None => return Zero::zero(),
+		};
+		let mut rest = value;
+		while !record.payouts.is_empty() {
+			if let Some(new_rest) = rest.checked_sub(&record.payouts[0].1) {
+				// not yet totally slashed after this one; drop it completely.
+				rest = new_rest;
+				record.payouts.remove(0);
 			} else {
-				<Defender<T, I>>::kill();
+				// whole slash is accounted for.
+				record.payouts[0].1.saturating_reduce(rest);
+				rest = Zero::zero();
+				break
 			}
 		}
+		Membership::<T, I>::insert(who, record);
+		value - rest
+	}
+
+	/// Transfer some `amount` from the main account into the payouts account and reduce the Pot
+	/// by this amount.
+	fn reserve_payout(amount: BalanceOf<T>) {
+		// Tramsfer payout from the Pot into the payouts account.
+		Pot::<T, I>::mutate(|pot| pot.saturating_reduce(amount));
+
+		// this should never fail since we ensure we can afford the payouts in a previous
+		// block, but there's not much we can do to recover if it fails anyway.
+		let res = T::Currency::transfer(
+			&Self::account_id(),
+			&Self::payouts(),
+			amount,
+			AllowDeath,
+		);
+		debug_assert!(res.is_ok());
+	}
+
+	/// Transfer some `amount` from the main account into the payouts account and increase the Pot
+	/// by this amount.
+	fn unreserve_payout(amount: BalanceOf<T>) {
+		// Tramsfer payout from the Pot into the payouts account.
+		Pot::<T, I>::mutate(|pot| pot.saturating_accrue(amount));
+
+		// this should never fail since we ensure we can afford the payouts in a previous
+		// block, but there's not much we can do to recover if it fails anyway.
+		let res = T::Currency::transfer(
+			&Self::payouts(),
+			&Self::account_id(),
+			amount,
+			AllowDeath,
+		);
+		debug_assert!(res.is_ok());
 	}
 
 	/// The account ID of the treasury pot.
@@ -1747,70 +1812,6 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		let lock_pc = 100 - 50_000 / (x + 500);
 		Percent::from_percent(lock_pc as u8) * T::MaxLockDuration::get()
 	}
-
-	/// Get a selection of bidding accounts such that the total bids is no greater than `Pot` and
-	/// the number of bids would not surpass `MaxMembers` if all were accepted.
-	///
-	/// May be empty.
-	pub fn take_selected(
-		members_len: usize,
-		pot: BalanceOf<T, I>,
-	) -> Vec<Bid<T::AccountId, BalanceOf<T, I>>> {
-		let max_members = MaxMembers::<T, I>::get() as usize;
-		let mut max_selections: usize =
-			(T::MaxCandidateIntake::get() as usize).min(max_members.saturating_sub(members_len));
-
-		if max_selections > 0 {
-			// Get the number of left-most bidders whose bids add up to less than `pot`.
-			let mut bids = <Bids<T, I>>::get();
-
-			// The list of selected candidates
-			let mut selected = Vec::new();
-
-			if bids.len() > 0 {
-				// Can only select at most the length of bids
-				max_selections = max_selections.min(bids.len());
-				// Number of selected bids so far
-				let mut count = 0;
-				// Check if we have already selected a candidate with zero bid
-				let mut zero_selected = false;
-				// A running total of the cost to onboard these bids
-				let mut total_cost: BalanceOf<T, I> = Zero::zero();
-
-				bids.retain(|bid| {
-					if count < max_selections {
-						// Handle zero bids. We only want one of them.
-						if bid.value.is_zero() {
-							// Select only the first zero bid
-							if !zero_selected {
-								selected.push(bid.clone());
-								zero_selected = true;
-								count += 1;
-								return false
-							}
-						} else {
-							total_cost += bid.value;
-							// Select only as many users as the pot can support.
-							if total_cost <= pot {
-								selected.push(bid.clone());
-								count += 1;
-								return false
-							}
-						}
-					}
-					true
-				});
-
-				// No need to reset Bids if we're not taking anything.
-				if count > 0 {
-					<Bids<T, I>>::put(bids);
-				}
-			}
-			selected
-		} else {
-			vec![]
-		}
-	}
 }
 
 impl<T: Config<I>, I: 'static> OnUnbalanced<NegativeImbalanceOf<T, I>> for Pallet<T, I> {
diff --git a/frame/society/src/mock.rs b/frame/society/src/mock.rs
index 04ea705eed556..3c84a3f66a39e 100644
--- a/frame/society/src/mock.rs
+++ b/frame/society/src/mock.rs
@@ -109,7 +109,7 @@ impl Config for Test {
 	type RotationPeriod = ConstU64<4>;
 	type MaxLockDuration = ConstU64<100>;
 	type FounderSetOrigin = EnsureSignedBy<FounderSetAccount, u128>;
-	type SuspensionJudgementOrigin = EnsureSignedBy<SuspensionJudgementSetAccount, u128>;
+	type JudgementOrigin = EnsureSignedBy<SuspensionJudgementSetAccount, u128>;
 	type ChallengePeriod = ConstU64<8>;
 	type MaxCandidateIntake = ConstU32<10>;
 	type PalletId = SocietyPalletId;
diff --git a/frame/support/src/storage/bounded_vec.rs b/frame/support/src/storage/bounded_vec.rs
index 92ca167f98436..5795edde24bc2 100644
--- a/frame/support/src/storage/bounded_vec.rs
+++ b/frame/support/src/storage/bounded_vec.rs
@@ -104,6 +104,11 @@ impl<T: Decode, S: Get<u32>> Decode for BoundedVec<T, S> {
 impl<T: Encode + Decode, S: Get<u32>> EncodeLike<Vec<T>> for BoundedVec<T, S> {}
 
 impl<T, S> BoundedVec<T, S> {
+	/// Create `Self` with no items.
+	fn new() -> Self {
+		Self(Vec::new(), Default::default())
+	}
+
 	/// Create `Self` from `t` without any checks.
 	fn unchecked_from(t: Vec<T>) -> Self {
 		Self(t, Default::default())
@@ -241,23 +246,23 @@ impl<T, S: Get<u32>> BoundedVec<T, S> {
 	/// If `Self::bound() < index` or `self.len() < index`, then this is also a no-op.
 	///
 	/// Returns `Ok(maybe_removed)` if the item was inserted, where `maybe_removed` is
-	/// `Some(removed)` if an item was removed to make room for the new one. Returns `Err(())` if
-	/// `element` cannot be inserted.
+	/// `Some(removed)` if an item was removed to make room for the new one. Returns `Err(element)`
+	/// if `element` cannot be inserted.
 	pub fn force_insert_keep_right(
 		&mut self,
 		index: usize,
 		mut element: T,
-	) -> Result<Option<T>, ()> {
+	) -> Result<Option<T>, T> {
 		// Check against panics.
 		if Self::bound() < index || self.len() < index {
-			Err(())
+			Err(element)
 		} else if self.len() < Self::bound() {
 			// Cannot panic since self.len() >= index;
 			self.0.insert(index, element);
 			Ok(None)
 		} else {
 			if index == 0 {
-				return Err(())
+				return Err(element)
 			}
 			sp_std::mem::swap(&mut self[0], &mut element);
 			// `[0..index] cannot panic since self.len() >= index.
@@ -275,16 +280,16 @@ impl<T, S: Get<u32>> BoundedVec<T, S> {
 	/// If `Self::bound() < index` or `self.len() < index`, then this is also a no-op.
 	///
 	/// Returns `Ok(maybe_removed)` if the item was inserted, where `maybe_removed` is
-	/// `Some(removed)` if an item was removed to make room for the new one. Returns `Err(())` if
-	/// `element` cannot be inserted.
-	pub fn force_insert_keep_left(&mut self, index: usize, element: T) -> Result<Option<T>, ()> {
+	/// `Some(removed)` if an item was removed to make room for the new one. Returns `Err(element)`
+	/// if `element` cannot be inserted.
+	pub fn force_insert_keep_left(&mut self, index: usize, element: T) -> Result<Option<T>, T> {
 		// Check against panics.
 		if Self::bound() < index || self.len() < index || Self::bound() == 0 {
-			return Err(())
+			return Err(element)
 		}
 		// Noop condition.
 		if Self::bound() == index && self.len() <= Self::bound() {
-			return Err(())
+			return Err(element)
 		}
 		let maybe_removed = if self.is_full() {
 			// defensive-only: since we are at capacity, this is a noop.
diff --git a/frame/support/src/storage/types/map.rs b/frame/support/src/storage/types/map.rs
index bc32c58da8db6..009a0c9fadb8b 100644
--- a/frame/support/src/storage/types/map.rs
+++ b/frame/support/src/storage/types/map.rs
@@ -316,6 +316,14 @@ where
 		<Self as crate::storage::IterableStorageMap<Key, Value>>::iter_from(starting_raw_key)
 	}
 
+	/// Enumerate all elements in the map after a specified `starting_key` in no
+	/// particular order.
+	///
+	/// If you alter the map while doing this, you'll get undefined results.
+	pub fn iter_from_key(starting_key: impl EncodeLike<Key>) -> crate::storage::PrefixIterator<(Key, Value)> {
+		Self::iter_from(Self::hashed_key_for(starting_key))
+	}
+
 	/// Enumerate all keys in the map in no particular order.
 	///
 	/// If you alter the map while doing this, you'll get undefined results.
@@ -331,6 +339,14 @@ where
 		<Self as crate::storage::IterableStorageMap<Key, Value>>::iter_keys_from(starting_raw_key)
 	}
 
+	/// Enumerate all keys in the map after a specified `starting_key` in no particular
+	/// order.
+	///
+	/// If you alter the map while doing this, you'll get undefined results.
+	pub fn iter_keys_from_from(starting_key: impl EncodeLike<Key>) -> crate::storage::KeyPrefixIterator<Key> {
+		Self::iter_keys_from(Self::hashed_key_for(starting_key))
+	}
+
 	/// Remove all elements from the map and iterate through them in no particular order.
 	///
 	/// If you add elements to the map while doing this, you'll get undefined results.
diff --git a/frame/system/src/lib.rs b/frame/system/src/lib.rs
index 14e67cfcd8156..81924eeb295d5 100644
--- a/frame/system/src/lib.rs
+++ b/frame/system/src/lib.rs
@@ -195,6 +195,7 @@ impl<MaxNormal: Get<u32>, MaxOverflow: Get<u32>> ConsumerLimits for (MaxNormal,
 pub mod pallet {
 	use crate::{self as frame_system, pallet_prelude::*, *};
 	use frame_support::pallet_prelude::*;
+	use sp_core::traits::FromEntropy;
 
 	/// System configuration trait. Implemented by runtime.
 	#[pallet::config]
@@ -275,7 +276,8 @@ pub mod pallet {
 			+ Debug
 			+ MaybeDisplay
 			+ Ord
-			+ MaxEncodedLen;
+			+ MaxEncodedLen
+			+ FromEntropy;
 
 		/// Converting trait to take a source type and convert to `AccountId`.
 		///
diff --git a/primitives/core/src/ecdsa.rs b/primitives/core/src/ecdsa.rs
index 6343e3f4dfd0d..ebb70e74e758d 100644
--- a/primitives/core/src/ecdsa.rs
+++ b/primitives/core/src/ecdsa.rs
@@ -74,6 +74,14 @@ type Seed = [u8; 32];
 )]
 pub struct Public(pub [u8; 33]);
 
+impl FromEntropy for Public {
+	fn from_entropy(input: &mut codec::Input) -> Result<Self, codec::Error> {
+		let mut result = Self([0u8; 33]);
+		input.read(&mut result.0[..])?;
+		Ok(result)
+	}
+}
+
 impl Public {
 	/// A new instance from the given 33-byte `data`.
 	///
diff --git a/primitives/core/src/ed25519.rs b/primitives/core/src/ed25519.rs
index 0bde9e2e5303a..bbb1ab74587e5 100644
--- a/primitives/core/src/ed25519.rs
+++ b/primitives/core/src/ed25519.rs
@@ -88,6 +88,14 @@ impl Clone for Pair {
 	}
 }
 
+impl FromEntropy for Public {
+	fn from_entropy(input: &mut codec::Input) -> Result<Self, codec::Error> {
+		let mut result = Self([0u8; 32]);
+		input.read(&mut result.0[..])?;
+		Ok(result)
+	}
+}
+
 impl AsRef<[u8; 32]> for Public {
 	fn as_ref(&self) -> &[u8; 32] {
 		&self.0
diff --git a/primitives/core/src/sr25519.rs b/primitives/core/src/sr25519.rs
index ef033c2099b5f..4e72f747a3a4e 100644
--- a/primitives/core/src/sr25519.rs
+++ b/primitives/core/src/sr25519.rs
@@ -42,7 +42,7 @@ use crate::{
 		ByteArray, CryptoType, CryptoTypeId, CryptoTypePublicPair, Derive, Public as TraitPublic,
 		UncheckedFrom,
 	},
-	hash::{H256, H512},
+	hash::{H256, H512}, traits::FromEntropy,
 };
 use codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
@@ -93,6 +93,14 @@ impl Clone for Pair {
 	}
 }
 
+impl FromEntropy for Public {
+	fn from_entropy(input: &mut codec::Input) -> Result<Self, codec::Error> {
+		let mut result = Self([0u8; 32]);
+		input.read(&mut result.0[..])?;
+		Ok(result)
+	}
+}
+
 impl AsRef<[u8; 32]> for Public {
 	fn as_ref(&self) -> &[u8; 32] {
 		&self.0
diff --git a/primitives/core/src/traits.rs b/primitives/core/src/traits.rs
index 80e8963a2909d..9ba35dd402548 100644
--- a/primitives/core/src/traits.rs
+++ b/primitives/core/src/traits.rs
@@ -278,3 +278,10 @@ impl SpawnEssentialNamed for Box<dyn SpawnEssentialNamed> {
 		(**self).spawn_essential(name, group, future)
 	}
 }
+
+/// Create random values of `Self` given a stream of entropy.
+pub trait FromEntropy {
+	/// Create a random value of `Self` given a stream of random bytes on `input`. May only fail if
+	/// `input` has an error.
+	fn from_entropy(input: &mut codec::Input) -> Result<Self, codec::Error>;
+}
diff --git a/primitives/runtime/src/lib.rs b/primitives/runtime/src/lib.rs
index 39e606eb9b5f4..e420a8a42377f 100644
--- a/primitives/runtime/src/lib.rs
+++ b/primitives/runtime/src/lib.rs
@@ -49,6 +49,7 @@ use sp_core::{
 	ecdsa, ed25519,
 	hash::{H256, H512},
 	sr25519,
+	traits::FromEntropy,
 };
 use sp_std::prelude::*;
 
@@ -169,7 +170,7 @@ impl From<Justification> for Justifications {
 	}
 }
 
-use traits::{Lazy, Verify};
+use traits::{Lazy, Verify, FromEntropy};
 
 use crate::traits::IdentifyAccount;
 #[cfg(feature = "std")]
@@ -302,6 +303,16 @@ pub enum MultiSigner {
 	Ecdsa(ecdsa::Public),
 }
 
+impl FromEntropy for MultiSigner {
+	fn from_entropy(input: &mut codec::Input) -> Result<Self, ()> {
+		Ok(match input.read_byte() % 3 {
+			0 => Self::Ed25519(FromEntropy::try_from_entropy(input)?),
+			1 => Self::Sr25519(FromEntropy::try_from_entropy(input)?),
+			2.. => Self::Ecdsa(FromEntropy::try_from_entropy(input)?),
+		})
+	}
+}
+
 /// NOTE: This implementations is required by `SimpleAddressDeterminer`,
 /// we convert the hash into some AccountId, it's fine to use any scheme.
 impl<T: Into<H256>> crypto::UncheckedFrom<T> for MultiSigner {

From 135009ccca8af79c749db7270e51a924ae6c2d4d Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@parity.io>
Date: Sat, 30 Apr 2022 15:32:07 +0200
Subject: [PATCH 02/43] More logic drafting

---
 frame/society/src/lib.rs               | 473 +++++++++++++------------
 frame/support/src/storage/mod.rs       |  13 +
 frame/support/src/storage/types/map.rs |   8 +
 3 files changed, 264 insertions(+), 230 deletions(-)

diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index b18140fc989e8..f526e33e43907 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -355,6 +355,28 @@ pub type RoundIndex = u32;
 /// The rank of a member.
 pub type Rank = u32;
 
+/// The number of votes.
+pub type Votes = u32;
+
+/// Tally of votes.
+#[derive(Default, Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub struct Tally {
+	/// The approval votes.
+	approvals: Votes,
+	/// The rejection votes.
+	rejections: Votes,
+}
+
+impl Tally {
+	fn more_approvals(&self) -> bool {
+		self.approvals > self.rejections
+	}
+
+	fn more_rejections(&self) -> bool {
+		self.rejections > self.approvals
+	}
+}
+
 /// A bid for entry into society.
 #[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
 pub struct Candidacy<AccountId, Balance> {
@@ -364,16 +386,14 @@ pub struct Candidacy<AccountId, Balance> {
 	kind: BidKind<AccountId, Balance>,
 	/// The reward that the bidder has requested for successfully joining the society.
 	bid: Balance,
-	/// The tally of explicit approval votes so far.
-	approvals: u32,
-	/// The tally of explicit rejection votes so far.
-	rejections: u32,
+	/// The tally of votes so far.
+	tally: Tally,
 }
 
 /// A vote by a member on a candidate application.
 #[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
 pub enum BidKind<AccountId, Balance> {
-	/// The CandidateDeposit was paid for this bid.
+	/// The given deposit was paid for this bid.
 	Deposit(Balance),
 	/// A member vouched for this bid. The account should be reinstated into `Members` once the
 	/// bid is successful (or if it is rescinded prior to launch).
@@ -381,16 +401,8 @@ pub enum BidKind<AccountId, Balance> {
 }
 
 impl<AccountId: PartialEq, Balance> BidKind<AccountId, Balance> {
-	fn check_voucher(&self, v: &AccountId) -> DispatchResult {
-		if let BidKind::Vouch(ref a, _) = self {
-			if a == v {
-				Ok(())
-			} else {
-				Err("incorrect identity")?
-			}
-		} else {
-			Err("not vouched")?
-		}
+	fn is_vouch(&self, v: &AccountId) -> DispatchResult {
+		matches!(self, BidKind::Vouch(ref a, _) if a == v)
 	}
 }
 
@@ -429,6 +441,16 @@ pub type IntakeRecordFor<T, I> = IntakeRecord<
 	BalanceOf<T, I>,
 >;
 
+#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub struct GroupParams<Balance> {
+	max_members: u32,
+	max_intake: u32,
+	max_strikes: u32,
+	candidate_deposit: Balance,
+}
+
+pub type GroupParamsFor<T> = GroupParams<BalanceOf<T, I>>;
+
 #[frame_support::pallet]
 pub mod pallet {
 	use super::*;
@@ -453,22 +475,7 @@ pub mod pallet {
 		/// Something that provides randomness in the runtime.
 		type Randomness: Randomness<Self::Hash, Self::BlockNumber>;
 
-		/// The minimum amount of a deposit required for a bid to be made.
-		#[pallet::constant]
-		type CandidateDeposit: Get<BalanceOf<Self, I>>;
-
-		/// The amount of the unpaid reward that gets deducted in the case that either a skeptic
-		/// doesn't vote or someone votes in the wrong way.
-		#[pallet::constant]
-		type WrongSideDeduction: Get<BalanceOf<Self, I>>;
-
-		/// The number of times a skeptic may not vote or vote the wrong way for a candidate before
-		/// they become suspended.
-		#[pallet::constant]
-		type MaxStrikes: Get<u32>;
-
-		/// The number of times a skeptic may not vote or vote the wrong way for a candidate before
-		/// they get any payouts slashed in half.
+		/// The maximum number of strikes before a member gets funds slashed.
 		#[pallet::constant]
 		type GraceStrikes: Get<u32>;
 
@@ -493,20 +500,10 @@ pub mod pallet {
 		/// The origin that is allowed to call `found`.
 		type FounderSetOrigin: EnsureOrigin<Self::Origin>;
 
-		/// The origin that is allowed to make suspension judgements.
-		type JudgementOrigin: EnsureOrigin<Self::Origin>;
-
 		/// The number of blocks between membership challenges.
 		#[pallet::constant]
 		type ChallengePeriod: Get<Self::BlockNumber>;
 
-		/// The maximum number of candidates that we accept per round.
-		#[pallet::constant]
-		type MaxCandidateIntake: Get<u32>;
-
-		/// The origin that is allowed to set the maximum number of members.
-		type AdminOrigin: Get<u32>;
-
 		/// The maximum number of payouts a member may have waiting unclaimed.
 		#[pallet::constant]
 		type MaxPayouts: Get<u32>;
@@ -518,8 +515,6 @@ pub mod pallet {
 
 	#[pallet::error]
 	pub enum Error<T, I = ()> {
-		/// An incorrect position was provided.
-		BadPosition,
 		/// User is not a member.
 		NotMember,
 		/// User is already a member.
@@ -568,6 +563,10 @@ pub mod pallet {
 		Expired,
 		/// User is not a bidder.
 		NotBidder,
+		/// There is no defender currently.
+		NoDefender,
+		/// Group doesn't exist.
+		NotGroup,
 	}
 
 	#[pallet::event]
@@ -602,8 +601,8 @@ pub mod pallet {
 		Vote { candidate: T::AccountId, voter: T::AccountId, vote: bool },
 		/// A vote has been placed for a defending member
 		DefenderVote { voter: T::AccountId, vote: bool },
-		/// A new \[max\] member count has been set
-		NewMaxMembers { max: u32 },
+		/// A new set of \[params\] has been set for the group.
+		NewParams { params: GroupParamsFor<T> },
 		/// Society is unfounded.
 		Unfounded { founder: T::AccountId },
 		/// Some funds were deposited into the society account.
@@ -616,7 +615,7 @@ pub mod pallet {
 
 	/// The max number of members for the society at one time.
 	#[pallet::storage]
-	pub(super) type MaxMembers<T: Config<I>, I: 'static = ()> = StorageValue<_, u32, ValueQuery>;
+	pub(super) type Parameters<T: Config<I>, I: 'static = ()> = StorageValue<_, GroupParamsFor<T>, OptionQuery>;
 
 	/// Amount of our account balance that is specifically for the next round's bid(s).
 	#[pallet::storage]
@@ -632,14 +631,23 @@ pub mod pallet {
 
 	/// A hash of the rules of this society concerning membership. Can only be set once and
 	/// only by the founder.
-	// TODO: Should be a map with rules for each rank and badge.
+	// TODO: Should be a map with rules for each rank and faction.
 	#[pallet::storage]
 	pub type Rules<T: Config<I>, I: 'static = ()> = StorageValue<_, T::Hash>;
 
 	/// The current members and their rank. Doesn't include `SuspendedMembers`.
 	#[pallet::storage]
-	pub type Membership<T: Config<I>, I: 'static = ()> =
+	pub type Members<T: Config<I>, I: 'static = ()> =
 		StorageMap<_, Twox64Concat, T::AccountId, MemberRecordFor<T>, OptionQuery>;
+	/*
+	// TODO: Migrate from:
+	pub(super) type Vouching<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Twox64Concat, T::AccountId, VouchingStatus>;
+	pub(super) type Strikes<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Twox64Concat, T::AccountId, StrikeCount, ValueQuery>;
+	pub type Members<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, Vec<T::AccountId>, ValueQuery>;
+	*/
 
 	/// The number of items in `Membership` currently. (Doesn't include `SuspendedMembers`.)
 	#[pallet::storage]
@@ -665,15 +673,20 @@ pub mod pallet {
 	pub(super) type Bids<T: Config<I>, I: 'static = ()> =
 		StorageValue<_, BoundedVec<Bid<T::AccountId, BalanceOf<T, I>>, T::MaxBids>, ValueQuery>;
 
+	/*
+	// TODO: Migrate from:
+	pub type Candidates<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, Vec<Bid<T::AccountId, BalanceOf<T, I>>>, ValueQuery>;
+	*/
 	#[pallet::storage]
-	pub type Candidate<T: Config<I>, I: 'static = ()> = StorageMap<_,
+	pub type Candidates<T: Config<I>, I: 'static = ()> = StorageMap<_,
 		Blake2_128Concat,
 		T::AccountId,
 		Candidacy<T::AccountId, BalanceOf<T, I>>,
 		OptionQuery,
 	>;
 
-	/// The current skeptics.
+	/// The current skeptic.
 	#[pallet::storage]
 	pub type Skeptic<T: Config<I>, I: 'static = ()> = StorageValue<_, Vec<T::AccountId>, ValueQuery>;
 
@@ -700,57 +713,19 @@ pub mod pallet {
 		OptionQuery,
 	>;
 
-	/// The defending member currently being challenged, along with a running tally of approval and
-	/// rejection votes.
+	/// The defending member currently being challenged, along with a running tally of votes.
 	#[pallet::storage]
-	pub(super) type Defending<T: Config<I>, I: 'static = ()> = StorageValue<_, (T::AccountId, T::AccountId, u32, u32)>;
+	pub(super) type Defending<T: Config<I>, I: 'static = ()> = StorageValue<_, (T::AccountId, T::AccountId, Tally)>;
 
 	/// Votes for the defender.
-	// TODO: Migrate (used to be `OldVote`)
 	#[pallet::storage]
 	pub(super) type DefenderVotes<T: Config<I>, I: 'static = ()> =
 		StorageMap<_, Twox64Concat, T::AccountId, Vote>;
-
-	// OLD STUFF
-
-	// Moved to `Member`.
-	// TODO: Needs refactor, migration into Membership, removal.
-	/// Members currently vouching or banned from vouching again.
-	#[pallet::storage]
-	pub(super) type Vouching<T: Config<I>, I: 'static = ()> =
-		StorageMap<_, Twox64Concat, T::AccountId, VouchingStatus>;
-
-	/// The ongoing number of losing votes cast by the member.
-	// TODO: Needs refactor, migration into Membership, removal.
-	#[pallet::storage]
-	pub(super) type Strikes<T: Config<I>, I: 'static = ()> =
-		StorageMap<_, Twox64Concat, T::AccountId, StrikeCount, ValueQuery>;
-
-	/// The current set of members, ordered.
-	// TODO: Needs refactor, migration into Membership, removal.
-	#[pallet::storage]
-	#[pallet::getter(fn members)]
-	pub type Members<T: Config<I>, I: 'static = ()> =
-		StorageValue<_, Vec<T::AccountId>, ValueQuery>;
-
-	/// The current set of candidates; bidders that are attempting to become members.
-	// TODO: Needs refactor, migration into Candidate, removal.
-	#[pallet::storage]
-	#[pallet::getter(fn candidates)]
-	pub type Candidates<T: Config<I>, I: 'static = ()> =
-		StorageValue<_, Vec<Bid<T::AccountId, BalanceOf<T, I>>>, ValueQuery>;
-
-	/// The set of suspended candidates.
-	// TODO: Needs refactor and removal.
-	// TODO: Ensure that it is empty immediately prior to upgrade.
-	#[pallet::storage]
-	#[pallet::getter(fn suspended_candidate)]
-	pub type SuspendedCandidates<T: Config<I>, I: 'static = ()> = StorageMap<
-		_,
-		Twox64Concat,
-		T::AccountId,
-		(BalanceOf<T, I>, BidKind<T::AccountId, BalanceOf<T, I>>),
-	>;
+	/*
+	// TODO: Migrate from
+	pub(super) type DefenderVotes<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Twox64Concat, T::AccountId, OldVote>;
+	*/
 
 	#[pallet::hooks]
 	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {
@@ -807,6 +782,12 @@ pub mod pallet {
 		}
 	}
 
+	mod migrations {
+		fn to_v2() {
+
+		}
+	}
+
 	#[pallet::genesis_build]
 	impl<T: Config<I>, I: 'static> GenesisBuild<T, I> for GenesisConfig<T, I> {
 		fn build(&self) {
@@ -827,7 +808,7 @@ pub mod pallet {
 	impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		/// A user outside of the society can make a bid for entry.
 		///
-		/// Payment: `CandidateDeposit` will be reserved for making a bid. It is returned
+		/// Payment: The group's Candidate Deposit will be reserved for making a bid. It is returned
 		/// when the bid becomes a member, or if the bid calls `unbid`.
 		///
 		/// The dispatch origin for this call must be _Signed_.
@@ -840,16 +821,19 @@ pub mod pallet {
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
 		pub fn bid(origin: OriginFor<T>, value: BalanceOf<T, I>) -> DispatchResult {
 			let who = ensure_signed(origin)?;
-			ensure!(!SuspendedMembers::<T, I>::contains_key(&who), Error::<T, I>::Suspended);
+
 			let mut bids = Bids::<T, I>::get();
 			ensure!(!Self::has_bid(&bids, &who), Error::<T, I>::AlreadyBid);
-			ensure!(!Candidate::<T, I>::contains_key(&who), Error::<T, I>::AlreadyCandidate);
-			ensure!(!Membership::<T, I>::contains_key(&who), Error::<T, I>::AlreadyMember);
+			ensure!(!Candidates::<T, I>::contains_key(&who), Error::<T, I>::AlreadyCandidate);
+			ensure!(!Members::<T, I>::contains_key(&who), Error::<T, I>::AlreadyMember);
+			ensure!(!SuspendedMembers::<T, I>::contains_key(&who), Error::<T, I>::Suspended);
+
+			let params = Parameters::<T, I>::get().ok_or(Error::<T, I>::NotGroup)?;
+			let deposit = params.candidate_deposit;
+			Self::insert_bid(&mut bids, &who, value.clone(), BidKind::Deposit(deposit));
 
-			let deposit = T::CandidateDeposit::get();
 			T::Currency::reserve(&who, deposit)?;
 
-			Self::insert_bid(&mut bids, &who, value.clone(), BidKind::Deposit(deposit));
 			Bids::<T, I>::put(bids);
 			Self::deposit_event(Event::<T, I>::Bid { candidate_id: who, offer: value });
 			Ok(())
@@ -905,23 +889,28 @@ pub mod pallet {
 			tip: BalanceOf<T, I>,
 		) -> DispatchResult {
 			let voucher = ensure_signed(origin)?;
-			// Check user is not suspended.
-			ensure!(!SuspendedCandidates::<T, I>::contains_key(&who), Error::<T, I>::Suspended);
-			ensure!(!SuspendedMembers::<T, I>::contains_key(&who), Error::<T, I>::Suspended);
-			// Check user is not a bid or candidate.
-			let bids = Bids::<T, I>::get();
+
+			// Get bids and check user is not bidding.
+			let mut bids = Bids::<T, I>::get();
 			ensure!(!Self::has_bid(&bids, &who), Error::<T, I>::AlreadyBid);
-			let candidates = Candidates::<T, I>::get();
-			ensure!(!Self::is_candidate(&candidates, &who), Error::<T, I>::AlreadyCandidate);
-			// Check user is not already a member.
-			let members = Members::<T, I>::get();
-			ensure!(!Self::is_member(&members, &who), Error::<T, I>::AlreadyMember);
+
+			// Check user is not already a candidate, member or suspended member.
+			ensure!(!Candidates::<T, I>::contains_key(&who), Error::<T, I>::AlreadyCandidate);
+			ensure!(!Members::<T, I>::contains_key(&who), Error::<T, I>::AlreadyMember);
+			ensure!(!SuspendedMembers::<T, I>::contains_key(&who), Error::<T, I>::Suspended);
+
 			// Check sender can vouch.
-			ensure!(Self::is_member(&members, &voucher), Error::<T, I>::NotMember);
-			ensure!(!Vouching::<T, I>::contains_key(&voucher), Error::<T, I>::AlreadyVouching);
+			let mut record = Members::<T, I>::get(voucher).ok_or(Error::<T, I>::NotMember)?;
+			ensure!(record.vouching.is_none(), Error::<T, I>::AlreadyVouching);
 
-			Vouching::<T, I>::insert(&voucher, VouchingStatus::Vouching);
-			Self::put_bid(bids, &who, value.clone(), BidKind::Vouch(voucher.clone(), tip));
+			// Update voucher record.
+			record.vouching = Some(VouchingStatus::Vouching);
+			// Update bids
+			Self::insert_bid(&mut bids, &who, value.clone(), BidKind::Vouch(voucher.clone(), tip));
+
+			// Write new state.
+			Members::<T, I>::insert(&voucher, &record);
+			Bids::<T, I>::put(bids);
 			Self::deposit_event(Event::<T, I>::Vouch {
 				candidate_id: who,
 				offer: value,
@@ -941,25 +930,18 @@ pub mod pallet {
 		/// Key: B (len of bids)
 		/// Total Complexity: O(B)
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
-		pub fn unvouch(origin: OriginFor<T>, pos: u32) -> DispatchResult {
+		pub fn unvouch(origin: OriginFor<T>) -> DispatchResult {
 			let voucher = ensure_signed(origin)?;
-			ensure!(
-				Vouching::<T, I>::get(&voucher) == Some(VouchingStatus::Vouching),
-				Error::<T, I>::NotVouching
-			);
-
-			let pos = pos as usize;
-			Bids::<T, I>::mutate(|b| {
-				if pos < b.len() {
-					b[pos].kind.check_voucher(&voucher)?;
-					Vouching::<T, I>::remove(&voucher);
-					let who = b.remove(pos).who;
-					Self::deposit_event(Event::<T, I>::Unvouch { candidate: who });
-					Ok(())
-				} else {
-					Err(Error::<T, I>::BadPosition)?
-				}
-			})
+
+			let mut bids = Bids::<T, I>::get();
+			let pos = bids.iter().position(|bid| bid.kind.is_vouch(&voucher))
+				.ok_or(Error::<T, I>::NotVouching)?;
+			let bid = bids.remove(pos);
+			Self::clean_bid(&bid);
+
+			Bids::<T, I>::put(bids);
+			Self::deposit_event(Event::<T, I>::Unvouch { candidate: bid.who });
+			Ok(())
 		}
 
 		/// As a member, vote on a candidate.
@@ -982,23 +964,14 @@ pub mod pallet {
 			let voter = ensure_signed(origin)?;
 			let candidate = T::Lookup::lookup(candidate)?;
 
-			let mut candidacy = Candidate::<T, I>::get(candidate).ok_or(Error::<T, I>::NotCandidate)?;
-			let record = Membership::<T, I>::get(&voter).ok_or(Error::<T, I>::NotMember)?;
+			let mut candidacy = Candidates::<T, I>::get(candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			let record = Members::<T, I>::get(&voter).ok_or(Error::<T, I>::NotMember)?;
 
-			// remove the old vote from the count, if there was one.
-			match Votes::<T, I>::get(&candidate, &voter) {
-				Some(Vote { approve: true, weight }) => candidacy.approves.saturating_reduce(weight),
-				Some(Vote { approve: false, weight }) => candidacy.rejects.saturating_reduce(weight),
-				_ => {},
-			}
-			let weight_root = record.rank + 1;
-			let weight = weight_root * weight_root;
-			match approve {
-				true => candidacy.approves.saturating_accrue(1),
-				false => candidacy.rejects.saturating_accrue(1),
-			}
-			Votes::<T, I>::insert(&candidate, &voter, Vote { approve, weight });
-			Candidate::<T, I>::insert(&candidate, &candidacy);
+			Votes::<T, I>::mutate(&candidate, &voter, |v| {
+				v = Some(Self::do_vote(v, approve, record.rank, &mut candidacy.tally));
+			});
+
+			Candidates::<T, I>::insert(&candidate, &candidacy);
 			Self::deposit_event(Event::<T, I>::Vote { candidate, voter, vote: approve });
 			Ok(())
 		}
@@ -1017,12 +990,15 @@ pub mod pallet {
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
 		pub fn defender_vote(origin: OriginFor<T>, approve: bool) -> DispatchResult {
 			let voter = ensure_signed(origin)?;
-			let members = Members::<T, I>::get();
-			ensure!(Self::is_member(&members, &voter), Error::<T, I>::NotMember);
 
-			let vote = if approve { Vote::Approve } else { Vote::Reject };
-			DefenderVotes::<T, I>::insert(&voter, vote);
+			let defending = Defending::<T, I>::get().ok_or(Error::<T, I>::NoDefender)?;
+			let record = Members::<T, I>::get(&voter).ok_or(Error::<T, I>::NotMember)?;
+
+			DefenderVotes::<T, I>::mutate(&voter, |v| {
+				v = Some(Self::do_vote(v, approve, record.rank, &mut defending.2));
+			});
 
+			Defending::<T, I>::put(defending);
 			Self::deposit_event(Event::<T, I>::DefenderVote { voter, vote: approve });
 			Ok(())
 		}
@@ -1043,14 +1019,14 @@ pub mod pallet {
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
 		pub fn payout(origin: OriginFor<T>) -> DispatchResult {
 			let who = ensure_signed(origin)?;
-			let mut record = Membership::<T, I>::get(&who).ok_or(Error::<T, I>::NotMember)?;
+			let mut record = Members::<T, I>::get(&who).ok_or(Error::<T, I>::NotMember)?;
 
 			if let Some((when, amount)) = record.payouts.first() {
 				if when <= &<frame_system::Pallet<T>>::block_number() {
 					record.paid = record.paid.checked_add(amount).ok_or(Overflow)?;
 					T::Currency::transfer(&Self::payouts(), &who, *amount, AllowDeath)?;
 					record.payouts.remove(0);
-					Membership::<T, I>::insert(&who, record);
+					Members::<T, I>::insert(&who, record);
 					return Ok(())
 				}
 			}
@@ -1081,22 +1057,30 @@ pub mod pallet {
 		/// Parameters:
 		/// - `founder` - The first member and head of the newly founded society.
 		/// - `max_members` - The initial max number of members for the society.
+		/// - `max_intake` - The maximum number of candidates per intake period.
+		/// - `max_strikes`: The maximum number of strikes a member may get before they become
+		///   suspended and may only be reinstated by the founder.
+		/// - `candidate_deposit`: The deposit required to make a bid for membership of the group.
 		/// - `rules` - The rules of this society concerning membership.
 		///
 		/// Complexity: O(1)
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
-		pub fn found(
+		pub fn found_society(
 			origin: OriginFor<T>,
 			founder: T::AccountId,
 			max_members: u32,
+			max_intake: u32,
+			max_strikes: u32,
+			candidate_deposit: BalanceOf<T, I>,
 			rules: Vec<u8>,
 		) -> DispatchResult {
 			T::FounderSetOrigin::ensure_origin(origin)?;
 			ensure!(!Head::<T, I>::exists(), Error::<T, I>::AlreadyFounded);
 			ensure!(max_members > 1, Error::<T, I>::MaxMembers);
 			// This should never fail in the context of this function...
-			MaxMembers::<T, I>::put(max_members);
-			Self::add_member(&founder, 1, BoundedVec::new())?;
+			let params = GroupParams { max_members, max_intake, max_strikes, candidate_deposit };
+			Parameters::<T, I>::put(params);
+			Self::insert_member(&founder, 1, BoundedVec::new())?;
 			Head::<T, I>::put(&founder);
 			Founder::<T, I>::put(&founder);
 			Rules::<T, I>::put(T::Hashing::hash(&rules));
@@ -1104,7 +1088,7 @@ pub mod pallet {
 			Ok(())
 		}
 
-		/// Annul the founding of the society.
+		/// Dissolve the society and remove all members.
 		///
 		/// The dispatch origin for this call must be Signed, and the signing account must be both
 		/// the `Founder` and the `Head`. This implies that it may only be done when there is one
@@ -1118,22 +1102,20 @@ pub mod pallet {
 		/// Total Complexity: O(1)
 		/// # </weight>
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
-		pub fn unfound(origin: OriginFor<T>) -> DispatchResult {
+		pub fn dissolve(origin: OriginFor<T>) -> DispatchResult {
 			let founder = ensure_signed(origin)?;
 			ensure!(Founder::<T, I>::get() == Some(founder.clone()), Error::<T, I>::NotFounder);
 			ensure!(Head::<T, I>::get() == Some(founder.clone()), Error::<T, I>::NotHead);
 
-			Members::<T, I>::kill();
+			Members::<T, I>::remove_all(None);
 			MemberCount::<T, I>::kill();
 			MemberByIndex::<T, I>::remove_all(None);
-			Membership::<T, I>::remove_all(None);
+			Members::<T, I>::remove_all(None);
 			Votes::<T, I>::remove_all(None);
 			Head::<T, I>::kill();
 			Founder::<T, I>::kill();
 			Rules::<T, I>::kill();
-			Candidates::<T, I>::kill();
-			Candidate::<T, I>::remove_all(None);
-			SuspendedCandidates::<T, I>::remove_all(None);
+			Candidates::<T, I>::remove_all(None);
 			Self::deposit_event(Event::<T, I>::Unfounded { founder });
 			Ok(())
 		}
@@ -1146,7 +1128,7 @@ pub mod pallet {
 		/// If a suspended member is rejected, remove all associated storage items, including
 		/// their payouts, and remove any vouched bids they currently have.
 		///
-		/// The dispatch origin for this call must be from the _JudgementOrigin_.
+		/// The dispatch origin for this call must be Signed from the Founder.
 		///
 		/// Parameters:
 		/// - `who` - The suspended member to be judged.
@@ -1161,7 +1143,9 @@ pub mod pallet {
 			who: T::AccountId,
 			forgive: bool,
 		) -> DispatchResult {
-			T::JudgementOrigin::ensure_origin(origin)?;
+			let founder = ensure_signed(origin)?;
+			ensure!(Founder::<T, I>::get() == Some(founder.clone()), Error::<T, I>::NotFounder);
+
 			let record = SuspendedMembers::<T, I>::get(&who).ok_or(Error::<T, I>::NotSuspended)?;
 
 			if forgive {
@@ -1176,21 +1160,33 @@ pub mod pallet {
 			Ok(())
 		}
 
-		/// Allows root origin to change the maximum number of members in society.
-		/// New max membership count must be no less than the current number of members.
+		/// Change the maximum number of members in society and the maximum number of new candidates
+		/// in a single intake period.
 		///
-		/// The dispatch origin for this call must be Root.
+		/// The dispatch origin for this call must be Signed by the Founder.
 		///
 		/// Parameters:
-		/// - `max` - The maximum number of members for the society.
+		/// - `max_members` - The maximum number of members for the society. This must be no
+		///   less than the current number of members.
+		/// - `max_intake` - The maximum number of candidates per intake period.
+		/// - `max_strikes`: The maximum number of strikes a member may get before they become
+		///   suspended and may only be reinstated by the founder.
+		/// - `candidate_deposit`: The deposit required to make a bid for membership of the group.
 		///
 		/// Total Complexity: O(1)
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
-		pub fn set_max_members(origin: OriginFor<T>, max: u32) -> DispatchResult {
-			T::AdminOrigin::ensure_origin(origin)?;
-			ensure!(max >= MemberCount::<T, I>::get(), Error::<T, I>::MaxMembers);
-			MaxMembers::<T, I>::put(max);
-			Self::deposit_event(Event::<T, I>::NewMaxMembers { max });
+		pub fn set_parameters(
+			origin: OriginFor<T>,
+			max_members: u32,
+			max_intake: u32,
+			max_strikes: u32,
+			candidate_deposit: BalanceOf<T, I>,
+		) -> DispatchResult {
+			ensure!(ensure_signed(origin)? == Founder::<T, I>::get(), Error::<T, I>::NotFounder);
+			ensure!(max_members >= MemberCount::<T, I>::get(), Error::<T, I>::MaxMembers);
+			let params = GroupParams { max_members, max_intake, max_strikes, candidate_deposit };
+			Parameters::<T, I>::put(&params);
+			Self::deposit_event(Event::<T, I>::NewParams { params });
 			Ok(())
 		}
 
@@ -1199,32 +1195,35 @@ pub mod pallet {
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
 		pub fn claim_membership(origin: OriginFor<T>) -> DispatchResult {
 			let candidate = ensure_signed(origin)?;
-			let candidacy = Candidate::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
-			ensure!(candidacy.approvals > candidacy.rejections, Error::<T, I>::NotApproved);
+			let candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			ensure!(candidacy.tally.more_approvals(), Error::<T, I>::NotApproved);
 			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
 			Self::induct_member(candidate, candidacy, 0)
 		}
 
-		/// Transform an approved candidate into a member. Callable only by the
-		/// `JudgementOrigin` and only after the period for voting has ended.
+		/// Transform an approved candidate into a member. Callable only by the Signed origin of the
+		/// Founder and only after the period for voting has ended.
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
 		pub fn force_membership(origin: OriginFor<T>, candidate: T::AccountId) -> DispatchResult {
-			T::JudgementOrigin::ensure_origin(origin)?;
-			let candidacy = Candidate::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			let founder = ensure_signed(origin)?;
+			ensure!(Founder::<T, I>::get() == Some(founder.clone()), Error::<T, I>::NotFounder);
+
+			let candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
 			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
 			Self::induct_member(candidate, candidacy, 0)
 		}
 
-		/// Remove the candidate's application from the society. Callable only by the
-		/// `JudgementOrigin` and the candidate, and only after the period for voting has ended.
+		/// Remove the candidate's application from the society. Callable only by the Signed origin
+		/// of the Founder, and only after the period for voting has ended.
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
 		pub fn kick_candidate(origin: OriginFor<T>, candidate: T::AccountId) -> DispatchResult {
-			T::JudgementOrigin::ensure_origin(origin)?;
-			let candidacy = Candidate::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			let founder = ensure_signed(origin)?;
+			ensure!(Founder::<T, I>::get() == Some(founder.clone()), Error::<T, I>::NotFounder);
+			let candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
 			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
 			Self::check_skeptic(&candidate, &candidacy);
 			Votes::<T, I>::remove_prefix(&candidate, None);
-			Candidate::<T, I>::remove(&candidate);
+			Candidates::<T, I>::remove(&candidate);
 			Ok(())
 		}
 
@@ -1233,12 +1232,12 @@ pub mod pallet {
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
 		pub fn resign_candidate(origin: OriginFor<T>) -> DispatchResult {
 			let candidate = ensure_signed(origin)?;
-			let candidacy = Candidate::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
-			ensure!(candidacy.approvals <= candidacy.rejections, Error::<T, I>::Approved);
+			let candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			ensure!(!candidacy.tally.more_approvals(), Error::<T, I>::Approved);
 			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
 			Self::check_skeptic(&candidate, &candidacy);
 			Votes::<T, I>::remove_prefix(&candidate, None);
-			Candidate::<T, I>::remove(&candidate);
+			Candidates::<T, I>::remove(&candidate);
 			Ok(())
 		}
 
@@ -1247,11 +1246,11 @@ pub mod pallet {
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
 		pub fn drop_candidate(origin: OriginFor<T>, candidate: T::AccountId) -> DispatchResult {
 			ensure_signed(origin)?;
-			let candidacy = Candidate::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
-			ensure!(candidacy.approvals <= candidacy.rejections, Error::<T, I>::Approved);
+			let candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			ensure!(!candidacy.tally.more_approvals(), Error::<T, I>::Approved);
 			ensure!(RoundCount::<T, I>::get() > candidacy.round + 1, Error::<T, I>::TooEarly);
 			Votes::<T, I>::remove_prefix(&candidate, None);
-			Candidate::<T, I>::remove(&candidate);
+			Candidates::<T, I>::remove(&candidate);
 			Ok(())
 		}
 	}
@@ -1275,20 +1274,7 @@ impl<T: Config> EnsureOrigin<T::Origin> for EnsureFounder<T> {
 	}
 }
 
-/// Pick an item at pseudo-random from the slice, given the `rng`. `None` iff the slice is empty.
-fn pick_item<'a, R: RngCore, T>(rng: &mut R, items: &'a [T]) -> Option<&'a T> {
-	if items.is_empty() {
-		None
-	} else {
-		Some(&items[pick_usize(rng, items.len() - 1)])
-	}
-}
-
-/// Pick a new PRN, in the range [0, `max`] (inclusive).
-fn pick_usize(rng: &mut impl RngCore, max: usize) -> usize {
-	(rng.next_u32() % (max as u32 + 1)) as usize
-}
-
+// TODO: Move close to `FromEntropy`?
 struct InputFromRng<'a, T>(&'a mut T);
 impl<'a, T: RngCore> codec::Input for InputFromRng<'a, T> {
 	fn remaining_len(&mut self) -> Result<Option<usize>, Error> {
@@ -1327,13 +1313,28 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		target_round == round && matches!(Self::period(), Period::Voting {..})
 	}
 
+	fn do_vote(maybe_old: Option<Vote>, approve: bool, rank: Rank, tally: &mut Tally) -> Vote {
+		match maybe_old {
+			Some(Vote { approve: true, weight }) => tally.approvals.saturating_reduce(weight),
+			Some(Vote { approve: false, weight }) => tally.rejections.saturating_reduce(weight),
+			_ => {},
+		}
+		let weight_root = rank + 1;
+		let weight = weight_root * weight_root;
+		match approve {
+			true => tally.approvals.saturating_accrue(1),
+			false => tally.rejections.saturating_accrue(1),
+		}
+		Vote { approve, weight }
+	}
+
 	fn check_skeptic(candidate: &T::AccountId, candidacy: &Candidacy<T::AccountId, BalanceOf<T>>) {
 		if RoundCount::<T, I>::get() != candidacy.round { return }
 		// We expect the skeptic to have voted.
 		let skeptic = Skeptic::<T, I>::get();
 		let maybe_vote = Votes::<T, I>::get(&candidate, &skeptic);
-		let approved = candidacy.approvals > candidacy.rejections;
-		let rejected = candidacy.rejections > candidacy.approvals;
+		let approved = candidacy.tally.more_approvals();
+		let rejected = candidacy.tally.more_rejections();
 		match (maybe_vote, approved, rejected) {
 			(None, _, _) | (Some(false), true, false) | (Some(true), false, true) => {
 				// Can't do much if the punishment doesn't work out.
@@ -1345,17 +1346,25 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 
 	/// End the current challenge period and start a new one.
 	fn rotate_challenge(rng: &mut impl RngCore) {
-		// TODO.
 		// End current defender rotation
-		if let Some((defender, skeptic, approvals, rejections)) = Defending::<T, I>::get() {
-			if rejections > approvals {
+		if let Some((defender, skeptic, tally)) = Defending::<T, I>::get() {
+			if tally.more_rejections() {
 				// Member has failed the challenge
 				Self::suspend_member(&defender);
 			}
 
-			// TODO: check skeptic voted and that their vote was with the majority. Slash if not.
+			// Check defender skeptic voted and that their vote was with the majority.
+			let skeptic_vote = DefenderVotes::<T, I>::get(&skeptic);
+			match (skeptic_vote, tally.more_approvals(), tally.more_rejections()) {
+				(None, _, _) | (Some(true), false, true) | (Some(false), true, false) => {
+					// Punish skeptic.
+					let _ = Self::strike_member(&skeptic);
+				}
+			}
 
 			// Clean up all votes.
+			// NOTE: To do lazy removal of this we'll need to store the challenge round so that
+			// voting when there's a stale vote does not lead to incorrect arithmetic.
 			DefenderVotes::<T, I>::remove_all(None);
 		}
 
@@ -1419,11 +1428,11 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		member_count: u32,
 		pot: BalanceOf<T, I>,
 	) -> usize {
-		let max_members = MaxMembers::<T, I>::get() as usize;
+		let max_members = Parameters::<T, I>::get().max_members as usize;
 
 		// Get the number of left-most bidders whose bids add up to less than `pot`.
 		let mut bids = Bids::<T, I>::get();
-		let mut max_selections: usize = (T::MaxCandidateIntake::get() as usize)
+		let mut max_selections: usize = (Parameters::<T, I>::get().max_intake as usize)
 			.min(max_members.saturating_sub(member_count))
 			.min(bids.len());
 
@@ -1442,10 +1451,9 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 					round,
 					kind: bid.kind,
 					bid: bid.value,
-					approvals: 0,
-					rejections: 0,
+					tally: Default::default(),
 				};
-				Candidate::<T, I>::insert(&bid.who, candidacy);
+				Candidates::<T, I>::insert(&bid.who, candidacy);
 				selections.saturating_inc();
 			}
 			!accept
@@ -1476,6 +1484,9 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	///
 	/// In neither case can we do much if the action isn't completable, but there's
 	/// no reason that either should fail.
+	///
+	/// WARNING: This alters the voucher item of `Members`. You must ensure that you do not
+	/// accidentally overwrite it with an older value after calling this.
 	fn clean_bid(bid: &Bid<T::AccountId, BalanceOf<T, I>>) {
 		match &bid.kind {
 			BidKind::Deposit(deposit) => {
@@ -1483,7 +1494,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 				debug_assert!(err_amount.is_zero());
 			},
 			BidKind::Vouch(voucher, _) => {
-				Vouching::<T, I>::remove(voucher);
+				Members::<T, I>::mutate_extant(voucher, |record| record.vouching = None);
 			},
 		}
 	}
@@ -1504,11 +1515,12 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	/// NOTE: Generally you should not use this, and instead use `add_new_member` or
 	/// `reinstate_member`, whose names clearly match the desired intention.
 	fn insert_member(who: &T::AccountId, rank: Rank, payouts: PayoutsFor<T>) -> DispatchResult {
-		ensure!(MemberCount::get() < MaxMembers::<T, I>::get() as usize, Error::<T, I>::MaxMembers);
+		let params = Parameters::<T, I>::get().ok_or(Error::<T, I>::NotGroup);
+		ensure!(MemberCount::get() < params.max_members as usize, Error::<T, I>::MaxMembers);
 		let index = MemberCount::<T, I>::mutate(|i| { i.saturating_accrue(1); *i - 1 });
 		let paid = Zero::zero();
 		let record = MemberRecord { rank, strikes: 0, vouching: None, paid, index, payouts };
-		Membership::<T, I>::insert(who, record);
+		Members::<T, I>::insert(who, record);
 		MemberByIndex::<T, I>::insert(index, who);
 		Ok(())
 	}
@@ -1546,19 +1558,20 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		let maturity = now + Self::lock_duration(MemberCount::<T, I>::get());
 		Self::reward_bidder(&candidate, candidacy.bid, candidacy.kind, maturity);
 		Votes::<T, I>::remove_prefix(&candidate, None);
-		Candidate::<T, I>::remove(&candidate);
+		Candidates::<T, I>::remove(&candidate);
 		Ok(())
 	}
 
 	fn strike_member(who: &T::AccountId) -> DispatchResult {
-		let mut record = Membership::<T, I>::get(who).ok_or(NotMember)?;
+		let mut record = Members::<T, I>::get(who).ok_or(NotMember)?;
 		record.strikes.saturating_inc();
 		if record.strikes >= T::GraceStrikes::get() {
 			// Too many strikes: slash the payout in half.
 			let total_payout = record.payouts.iter().map(|x| x.1).sum();
 			Self::slash_payout(who, total_payout / 2u32.into());
 		}
-		if record.strikes >= T::MaxStrikes::get() {
+		let params = Parameters::<T, I>::get().ok_or(Error::<T, I>::NotGroup)?;
+		if record.strikes >= params.max_strikes {
 			// Way too many strikes: suspend.
 			Self::suspend_member(who);
 		}
@@ -1578,14 +1591,14 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	pub fn remove_member(m: &T::AccountId) -> Result<MemberRecord, DispatchError> {
 		ensure!(Head::<T, I>::get().as_ref() != Some(m), Error::<T, I>::Head);
 		ensure!(Founder::<T, I>::get().as_ref() != Some(m), Error::<T, I>::Founder);
-		if let Some(record) = Membership::<T, I>::get(m) {
+		if let Some(record) = Members::<T, I>::get(m) {
 			let index = record.index;
 			let last_index = MemberCount::<T, I>::mutate(|i| { i.saturating_reduce(1); *i });
 			if index != last_index {
 				// Move the member with the last index down to the index of the member to be removed.
 				if let Some(other) = MemberByIndex::<T, I>::get(last_index) {
 					MemberByIndex::<T, I>::insert(index, other);
-					Membership::<T, I>::mutate(other, |m_r|
+					Members::<T, I>::mutate(other, |m_r|
 						if let Some(r) = m_r { r.index = index }
 					);
 				} else {
@@ -1594,7 +1607,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 			}
 
 			MemberByIndex::<T, I>::remove(last_index);
-			Membership::<T, I>::remove(m);
+			Members::<T, I>::remove(m);
 			// Remove their vouching status, potentially unbanning them in the future.
 			if record.vouching.take() == Some(VouchingStatus::Vouching) {
 				// Try to remove their bid if they are vouching.
@@ -1718,7 +1731,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	/// is not a member or if `value` is zero.
 	fn bump_payout(who: &T::AccountId, when: T::BlockNumber, value: BalanceOf<T, I>) {
 		if !value.is_zero() {
-			Membership::<T, I>::mutate(who, |maybe_record| if let Some(record) = maybe_record {
+			Members::<T, I>::mutate(who, |maybe_record| if let Some(record) = maybe_record {
 				if record.rank == 0 {
 					// Members of rank 1 never get payouts.
 					match record.payouts.binary_search_by_key(&when, |x| x.0) {
@@ -1733,7 +1746,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 
 	/// Attempt to slash the payout of some member. Return the total amount that was deducted.
 	fn slash_payout(who: &T::AccountId, value: BalanceOf<T, I>) -> BalanceOf<T, I> {
-		let mut record = match Membership::<T, I>::get(who) {
+		let mut record = match Members::<T, I>::get(who) {
 			Some(record) => record,
 			None => return Zero::zero(),
 		};
@@ -1750,7 +1763,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 				break
 			}
 		}
-		Membership::<T, I>::insert(who, record);
+		Members::<T, I>::insert(who, record);
 		value - rest
 	}
 
diff --git a/frame/support/src/storage/mod.rs b/frame/support/src/storage/mod.rs
index 066422ad456aa..3b617d3181fd7 100644
--- a/frame/support/src/storage/mod.rs
+++ b/frame/support/src/storage/mod.rs
@@ -184,6 +184,19 @@ pub trait StorageMap<K: FullEncode, V: FullCodec> {
 		f: F,
 	) -> Result<R, E>;
 
+	/// Mutate the value under a key if the value already exists. Do nothing and return the default
+	/// value if not.
+	fn mutate_extant<
+		KeyArg: EncodeLike<K>,
+		R: Default,
+		F: FnOnce(&mut V) -> R,
+	>(key: KeyArg, f: F) -> R {
+		Self::mutate_exists(key, |maybe_v| match maybe_v {
+			Some(ref mut value) => f(value),
+			None => R::default(),
+		})
+	}
+
 	/// Mutate the value under a key.
 	///
 	/// Deletes the item if mutated to a `None`.
diff --git a/frame/support/src/storage/types/map.rs b/frame/support/src/storage/types/map.rs
index 009a0c9fadb8b..e786c1fd4357d 100644
--- a/frame/support/src/storage/types/map.rs
+++ b/frame/support/src/storage/types/map.rs
@@ -165,6 +165,14 @@ where
 		<Self as crate::storage::StorageMap<Key, Value>>::try_mutate(key, f)
 	}
 
+	/// Mutate the value under a key iff it exists. Do nothing and return the default value if not.
+	pub fn mutate_extant<KeyArg: EncodeLike<Key>, R, F: FnOnce(&mut Value) -> R>(
+		key: KeyArg,
+		f: F,
+	) -> R {
+		<Self as crate::storage::StorageMap<Key, Value>>::mutate_extant(key, f)
+	}
+
 	/// Mutate the value under a key. Deletes the item if mutated to a `None`.
 	pub fn mutate_exists<KeyArg: EncodeLike<Key>, R, F: FnOnce(&mut Option<Value>) -> R>(
 		key: KeyArg,

From 01c68345f0b7d35789d1147c4ae08be6448892f3 Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@parity.io>
Date: Tue, 3 May 2022 12:27:29 +0200
Subject: [PATCH 03/43] More work

---
 frame/society/src/lib.rs | 100 +++++++++++++++++++++++++++------------
 1 file changed, 70 insertions(+), 30 deletions(-)

diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index f526e33e43907..ce36c799c1477 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -30,7 +30,6 @@
 //! At any point, a user in the society can be one of a:
 //! * Bidder - A user who has submitted intention of joining the society.
 //! * Candidate - A user who will be voted on to join the society.
-//! * Suspended Candidate - A user who failed to win a vote.
 //! * Member - A user who is a member of the society.
 //! * Suspended Member - A member of the society who has accumulated too many strikes
 //! or failed their membership challenge.
@@ -413,16 +412,21 @@ pub type PayoutsFor<T, I> = BoundedVec<
 
 /// Information concerning a member.
 #[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
-pub struct MemberRecord<Balance, BlockNumber, MaxPayouts> {
+pub struct MemberRecord {
 	rank: Rank,
 	strikes: StrikeCount,
 	vouching: Option<VouchingStatus>,
-	paid: Balance,
 	index: u32,
+}
+
+/// Information concerning a member.
+#[derive(Default, Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub struct PayoutRecord<Balance, BlockNumber, MaxPayouts> {
+	paid: Balance,
 	payouts: BoundedVec<(BlockNumber, Balance), MaxPayouts>,
 }
 
-pub type MemberRecordFor<T, I> = MemberRecord<
+pub type PayoutRecordFor<T, I> = PayoutRecord<
 	BalanceOf<T, I>,
 	<T as frame_system::Config>::BlockNumber,
 	<T as Config<I>>::MaxPayouts,
@@ -451,6 +455,21 @@ pub struct GroupParams<Balance> {
 
 pub type GroupParamsFor<T> = GroupParams<BalanceOf<T, I>>;
 
+pub type FactionIndex = u32;
+
+pub enum Faction {
+	Society,
+	Splinter(FactionIndex),
+}
+
+/// A group is just the rank of a faction.
+pub struct Group {
+	faction: Faction,
+	rank: Rank,
+}
+
+//TODO: Ranks cannot be indexed linearly. Should just be done as Groups DAG.
+
 #[frame_support::pallet]
 pub mod pallet {
 	use super::*;
@@ -567,6 +586,8 @@ pub mod pallet {
 		NoDefender,
 		/// Group doesn't exist.
 		NotGroup,
+		/// The member is already elevated to this rank.
+		AlreadyElevated,
 	}
 
 	#[pallet::event]
@@ -607,6 +628,8 @@ pub mod pallet {
 		Unfounded { founder: T::AccountId },
 		/// Some funds were deposited into the society account.
 		Deposit { value: BalanceOf<T, I> },
+		/// A \[member\] got elevated to \[rank\].
+		Elevated { member: T::AccountId, rank: Rank },
 	}
 
 	/// Old name generated by `decl_event`.
@@ -622,23 +645,25 @@ pub mod pallet {
 	pub type Pot<T: Config<I>, I: 'static = ()> = StorageValue<_, BalanceOf<T, I>, ValueQuery>;
 
 	/// The first member.
+	// TODO: Rename to `Faction` as a map on `FactionIndex`.
 	#[pallet::storage]
 	pub type Founder<T: Config<I>, I: 'static = ()> = StorageValue<_, T::AccountId>;
 
-	/// The most primary from the most recently approved members.
+	/// The most primary from the most recently approved rank 0 members in the society.
 	#[pallet::storage]
 	pub type Head<T: Config<I>, I: 'static = ()> = StorageValue<_, T::AccountId>;
 
 	/// A hash of the rules of this society concerning membership. Can only be set once and
 	/// only by the founder.
 	// TODO: Should be a map with rules for each rank and faction.
+	// TODO: Rename to `GroupMeta` as a map on `GroupIndex` and include `name: String`.
 	#[pallet::storage]
 	pub type Rules<T: Config<I>, I: 'static = ()> = StorageValue<_, T::Hash>;
 
 	/// The current members and their rank. Doesn't include `SuspendedMembers`.
 	#[pallet::storage]
 	pub type Members<T: Config<I>, I: 'static = ()> =
-		StorageMap<_, Twox64Concat, T::AccountId, MemberRecordFor<T>, OptionQuery>;
+		StorageMap<_, Twox64Concat, T::AccountId, MemberRecord, OptionQuery>;
 	/*
 	// TODO: Migrate from:
 	pub(super) type Vouching<T: Config<I>, I: 'static = ()> =
@@ -649,20 +674,29 @@ pub mod pallet {
 		StorageValue<_, Vec<T::AccountId>, ValueQuery>;
 	*/
 
-	/// The number of items in `Membership` currently. (Doesn't include `SuspendedMembers`.)
+	/// Information regarding rank-0 payouts, past and future.
+	#[pallet::storage]
+	pub type Payouts<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Twox64Concat, T::AccountId, PayoutRecordFor<T, I>, ValueQuery>;
+	/*
+	// TODO: Migrate from:
+	pub(super) type Payouts<T: Config<I>, I: 'static = ()> = ???
+	*/
+
+	/// The number of items in `Members` currently. (Doesn't include `SuspendedMembers`.)
 	#[pallet::storage]
 	pub type MemberCount<T: Config<I>, I: 'static = ()> = StorageValue<_, u32, ValueQuery>;
 
-	/// The current items in `Membership` keyed by their unique index. Keys are densely populated
+	/// The current items in `Members` keyed by their unique index. Keys are densely populated
 	/// `0..MemberCount` (does not include `MemberCount`).
 	#[pallet::storage]
 	pub type MemberByIndex<T: Config<I>, I: 'static = ()> =
 		StorageMap<_, Twox64Concat, u32, T::AccountId, OptionQuery>;
 
-	/// The set of suspended members.
+	/// The set of suspended members, with their old membership record.
 	#[pallet::storage]
 	pub type SuspendedMembers<T: Config<I>, I: 'static = ()> =
-		StorageMap<_, Twox64Concat, T::AccountId, MemberRecordFor<T>, OptionQuery>;
+		StorageMap<_, Twox64Concat, T::AccountId, MemberRecord, OptionQuery>;
 
 	/// The number of rounds which have passed.
 	#[pallet::storage]
@@ -1019,7 +1053,7 @@ pub mod pallet {
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
 		pub fn payout(origin: OriginFor<T>) -> DispatchResult {
 			let who = ensure_signed(origin)?;
-			let mut record = Members::<T, I>::get(&who).ok_or(Error::<T, I>::NotMember)?;
+			let mut record = Payouts::<T, I>::get(&who).ok_or(Error::<T, I>::NotMember)?;
 
 			if let Some((when, amount)) = record.payouts.first() {
 				if when <= &<frame_system::Pallet<T>>::block_number() {
@@ -1033,18 +1067,24 @@ pub mod pallet {
 			Err(Error::<T, I>::NoPayout)?
 		}
 
-		/// Repay the payment previously given to the member with the signed origin, and elevate
-		/// them from rank 0 to rank 1.
+		/// Repay the payment previously given to the member with the signed origin, remove any
+		/// pending payments, and elevate them from rank 0 to rank 1.
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
-		pub fn repay(origin: OriginFor<T>) -> DispatchResult {
-			todo!()
-		}
+		pub fn waive_repay(origin: OriginFor<T>) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let mut record = Members::<T, I>::get(&who).ok_or(Error::<T, I>::NotMember)?;
+			let mut payout_record = Payouts::<T, I>::get(&who).ok_or(Error::<T, I>::NotMember)?;
+			ensure!(record.rank == 0, Error::<T, I>::AlreadyElevated);
 
-		/// Remove the payment owed to the member with the signed origin, and elevate them from
-		/// rank 0 to rank 1.
-		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
-		pub fn waive(origin: OriginFor<T>) -> DispatchResult {
-			todo!()
+			T::Currency::transfer(&who, &Self::account_id(), payout_record.paid, AllowDeath)?;
+			payout_record.payouts.clear();
+			record.rank = 1;
+			Members::<T, I>::insert(&who, record);
+			Payouts::<T, I>::insert(&who, payout_record);
+
+			Self::deposit_event(Event::<T, I>::Elevated { member: who, rank: 1 });
+
+			Ok(())
 		}
 
 		/// Found the society.
@@ -1080,7 +1120,7 @@ pub mod pallet {
 			// This should never fail in the context of this function...
 			let params = GroupParams { max_members, max_intake, max_strikes, candidate_deposit };
 			Parameters::<T, I>::put(params);
-			Self::insert_member(&founder, 1, BoundedVec::new())?;
+			Self::insert_member(&founder, 1)?;
 			Head::<T, I>::put(&founder);
 			Founder::<T, I>::put(&founder);
 			Rules::<T, I>::put(T::Hashing::hash(&rules));
@@ -1150,9 +1190,10 @@ pub mod pallet {
 
 			if forgive {
 				// Try to add member back to society. Can fail with `MaxMembers` limit.
-				Self::reinstate_member(&who, record.rank, record.payouts)?;
+				Self::reinstate_member(&who, record.rank)?;
 			} else {
-				Self::unreserve_payout(record.payouts.into_iter().map(|x| x.1).sum());
+				let mut payout_record = Payouts::<T, I>::take(&who);
+				Self::unreserve_payout(payout_record.payouts.into_iter().map(|x| x.1).sum());
 			}
 
 			SuspendedMembers::<T, I>::remove(&who);
@@ -1514,12 +1555,11 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	///
 	/// NOTE: Generally you should not use this, and instead use `add_new_member` or
 	/// `reinstate_member`, whose names clearly match the desired intention.
-	fn insert_member(who: &T::AccountId, rank: Rank, payouts: PayoutsFor<T>) -> DispatchResult {
+	fn insert_member(who: &T::AccountId, rank: Rank) -> DispatchResult {
 		let params = Parameters::<T, I>::get().ok_or(Error::<T, I>::NotGroup);
 		ensure!(MemberCount::get() < params.max_members as usize, Error::<T, I>::MaxMembers);
 		let index = MemberCount::<T, I>::mutate(|i| { i.saturating_accrue(1); *i - 1 });
-		let paid = Zero::zero();
-		let record = MemberRecord { rank, strikes: 0, vouching: None, paid, index, payouts };
+		let record = MemberRecord { rank, strikes: 0, vouching: None, index };
 		Members::<T, I>::insert(who, record);
 		MemberByIndex::<T, I>::insert(index, who);
 		Ok(())
@@ -1531,14 +1571,14 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	///
 	/// The `payouts` value must be exactly as it was prior to suspension since no further funds
 	/// will be reserved.
-	fn reinstate_member(who: &T::AccountId, rank: Rank, payouts: PayoutsFor<T>) -> DispatchResult {
-		Self::insert_member(who, rank, payouts)
+	fn reinstate_member(who: &T::AccountId, rank: Rank) -> DispatchResult {
+		Self::insert_member(who, rank)
 	}
 
 	/// Add a member to the sorted members list. If the user is already a member, do nothing.
 	/// Can fail when `MaxMember` limit is reached, but in that case it has no side-effects.
 	fn add_new_member(who: &T::AccountId, rank: Rank) -> DispatchResult {
-		Self::insert_member(who, rank, Default::default())
+		Self::insert_member(who, rank)
 	}
 
 	/// Induct a new member into the set.

From a6577e0f22e689a10d556c0ff61adc68b0a91371 Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@parity.io>
Date: Tue, 3 May 2022 15:59:50 +0100
Subject: [PATCH 04/43] Building

---
 frame/society/src/lib.rs                 | 220 ++++++++++++-----------
 frame/support/src/storage/bounded_vec.rs |   7 +-
 frame/support/src/storage/types/map.rs   |   2 +-
 primitives/core/src/ecdsa.rs             |   4 +-
 primitives/core/src/ed25519.rs           |   4 +-
 primitives/core/src/sr25519.rs           |   2 +-
 primitives/core/src/traits.rs            |   4 +-
 primitives/runtime/src/lib.rs            |  12 +-
 8 files changed, 135 insertions(+), 120 deletions(-)

diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index ce36c799c1477..9d5a143f88380 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -256,7 +256,7 @@ mod tests;
 use frame_support::{
 	pallet_prelude::*,
 	traits::{
-		BalanceStatus, ChangeMembers, Currency, EnsureOrigin, ExistenceRequirement::AllowDeath,
+		Currency, EnsureOrigin, ExistenceRequirement::AllowDeath,
 		Imbalance, OnUnbalanced, Randomness, ReservableCurrency,
 	},
 	PalletId,
@@ -269,7 +269,7 @@ use rand_chacha::{
 use scale_info::TypeInfo;
 use sp_runtime::{
 	traits::{
-		AccountIdConversion, CheckedAdd, CheckedSub, Hash, IntegerSquareRoot, Saturating,
+		AccountIdConversion, CheckedAdd, CheckedSub, Hash, Saturating,
 		StaticLookup, TrailingZeroInput, Zero,
 	},
 	ArithmeticError::Overflow, Percent, RuntimeDebug,
@@ -295,6 +295,7 @@ pub enum OldVote {
 	Approve,
 }
 
+#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
 pub struct Vote {
 	approve: bool,
 	weight: u32,
@@ -355,15 +356,15 @@ pub type RoundIndex = u32;
 pub type Rank = u32;
 
 /// The number of votes.
-pub type Votes = u32;
+pub type VoteCount = u32;
 
 /// Tally of votes.
 #[derive(Default, Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
 pub struct Tally {
 	/// The approval votes.
-	approvals: Votes,
+	approvals: VoteCount,
 	/// The rejection votes.
-	rejections: Votes,
+	rejections: VoteCount,
 }
 
 impl Tally {
@@ -400,7 +401,7 @@ pub enum BidKind<AccountId, Balance> {
 }
 
 impl<AccountId: PartialEq, Balance> BidKind<AccountId, Balance> {
-	fn is_vouch(&self, v: &AccountId) -> DispatchResult {
+	fn is_vouch(&self, v: &AccountId) -> bool {
 		matches!(self, BidKind::Vouch(ref a, _) if a == v)
 	}
 }
@@ -420,16 +421,18 @@ pub struct MemberRecord {
 }
 
 /// Information concerning a member.
-#[derive(Default, Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
-pub struct PayoutRecord<Balance, BlockNumber, MaxPayouts> {
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, Default)]
+pub struct PayoutRecord<Balance, PayoutsVec> {
 	paid: Balance,
-	payouts: BoundedVec<(BlockNumber, Balance), MaxPayouts>,
+	payouts: PayoutsVec,
 }
 
 pub type PayoutRecordFor<T, I> = PayoutRecord<
 	BalanceOf<T, I>,
-	<T as frame_system::Config>::BlockNumber,
-	<T as Config<I>>::MaxPayouts,
+	BoundedVec<
+		(<T as frame_system::Config>::BlockNumber, BalanceOf<T, I>),
+		<T as Config<I>>::MaxPayouts,
+	>,
 >;
 
 /// Record for an individual new member who was elevated from a candidate recently.
@@ -453,8 +456,8 @@ pub struct GroupParams<Balance> {
 	candidate_deposit: Balance,
 }
 
-pub type GroupParamsFor<T> = GroupParams<BalanceOf<T, I>>;
-
+pub type GroupParamsFor<T, I> = GroupParams<BalanceOf<T, I>>;
+/*
 pub type FactionIndex = u32;
 
 pub enum Faction {
@@ -467,8 +470,9 @@ pub struct Group {
 	faction: Faction,
 	rank: Rank,
 }
-
-//TODO: Ranks cannot be indexed linearly. Should just be done as Groups DAG.
+*/
+//TODO: Ranks cannot be indexed linearly if we want to do insertions into the ranking system.
+//  Should just be done as Groups DAG.
 
 #[frame_support::pallet]
 pub mod pallet {
@@ -623,7 +627,7 @@ pub mod pallet {
 		/// A vote has been placed for a defending member
 		DefenderVote { voter: T::AccountId, vote: bool },
 		/// A new set of \[params\] has been set for the group.
-		NewParams { params: GroupParamsFor<T> },
+		NewParams { params: GroupParamsFor<T, I> },
 		/// Society is unfounded.
 		Unfounded { founder: T::AccountId },
 		/// Some funds were deposited into the society account.
@@ -638,7 +642,7 @@ pub mod pallet {
 
 	/// The max number of members for the society at one time.
 	#[pallet::storage]
-	pub(super) type Parameters<T: Config<I>, I: 'static = ()> = StorageValue<_, GroupParamsFor<T>, OptionQuery>;
+	pub(super) type Parameters<T: Config<I>, I: 'static = ()> = StorageValue<_, GroupParamsFor<T, I>, OptionQuery>;
 
 	/// Amount of our account balance that is specifically for the next round's bid(s).
 	#[pallet::storage]
@@ -722,7 +726,7 @@ pub mod pallet {
 
 	/// The current skeptic.
 	#[pallet::storage]
-	pub type Skeptic<T: Config<I>, I: 'static = ()> = StorageValue<_, Vec<T::AccountId>, ValueQuery>;
+	pub type Skeptic<T: Config<I>, I: 'static = ()> = StorageValue<_, T::AccountId, OptionQuery>;
 
 	/// Double map from Candidate -> Voter -> (Maybe) Vote.
 	#[pallet::storage]
@@ -743,7 +747,7 @@ pub mod pallet {
 	/// become the new `Head`.
 	#[pallet::storage]
 	pub type NextHead<T: Config<I>, I: 'static = ()> = StorageValue<_,
-		IntakeRecordFor<T>,
+		IntakeRecordFor<T, I>,
 		OptionQuery,
 	>;
 
@@ -764,8 +768,6 @@ pub mod pallet {
 	#[pallet::hooks]
 	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {
 		fn on_initialize(n: T::BlockNumber) -> Weight {
-			let mut members = vec![];
-
 			let mut weight = 0;
 			let weights = T::BlockWeights::get();
 
@@ -781,7 +783,7 @@ pub mod pallet {
 
 			// Run a candidate/membership rotation
 			match Self::period() {
-				Period::Voting { elapsed: 0, .. } => {
+				Period::Voting { elapsed, .. } if elapsed.is_zero() => {
 					Self::rotate_intake(&mut rng);
 					weight += weights.max_block / 20;
 				},
@@ -801,8 +803,6 @@ pub mod pallet {
 	#[pallet::genesis_config]
 	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {
 		pub pot: BalanceOf<T, I>,
-		pub members: Vec<T::AccountId>,
-		pub max_members: u32,
 	}
 
 	#[cfg(feature = "std")]
@@ -810,34 +810,25 @@ pub mod pallet {
 		fn default() -> Self {
 			Self {
 				pot: Default::default(),
-				members: Default::default(),
-				max_members: Default::default(),
 			}
 		}
 	}
 
-	mod migrations {
-		fn to_v2() {
-
-		}
-	}
-
 	#[pallet::genesis_build]
 	impl<T: Config<I>, I: 'static> GenesisBuild<T, I> for GenesisConfig<T, I> {
 		fn build(&self) {
 			Pot::<T, I>::put(self.pot);
-			MaxMembers::<T, I>::put(self.max_members);
-			let first_member = self.members.first();
-			if let Some(member) = first_member {
-				Founder::<T, I>::put(member.clone());
-				Head::<T, I>::put(member.clone());
-			};
-			let mut m = self.members.clone();
-			m.sort();
-			Members::<T, I>::put(m);
 		}
 	}
 
+	mod migrations {
+		/*
+		fn to_v2() {
+
+		}
+		*/
+	}
+
 	#[pallet::call]
 	impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		/// A user outside of the society can make a bid for entry.
@@ -934,7 +925,7 @@ pub mod pallet {
 			ensure!(!SuspendedMembers::<T, I>::contains_key(&who), Error::<T, I>::Suspended);
 
 			// Check sender can vouch.
-			let mut record = Members::<T, I>::get(voucher).ok_or(Error::<T, I>::NotMember)?;
+			let mut record = Members::<T, I>::get(&voucher).ok_or(Error::<T, I>::NotMember)?;
 			ensure!(record.vouching.is_none(), Error::<T, I>::AlreadyVouching);
 
 			// Update voucher record.
@@ -998,11 +989,11 @@ pub mod pallet {
 			let voter = ensure_signed(origin)?;
 			let candidate = T::Lookup::lookup(candidate)?;
 
-			let mut candidacy = Candidates::<T, I>::get(candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			let mut candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
 			let record = Members::<T, I>::get(&voter).ok_or(Error::<T, I>::NotMember)?;
 
 			Votes::<T, I>::mutate(&candidate, &voter, |v| {
-				v = Some(Self::do_vote(v, approve, record.rank, &mut candidacy.tally));
+				*v = Some(Self::do_vote(*v, approve, record.rank, &mut candidacy.tally));
 			});
 
 			Candidates::<T, I>::insert(&candidate, &candidacy);
@@ -1025,11 +1016,11 @@ pub mod pallet {
 		pub fn defender_vote(origin: OriginFor<T>, approve: bool) -> DispatchResult {
 			let voter = ensure_signed(origin)?;
 
-			let defending = Defending::<T, I>::get().ok_or(Error::<T, I>::NoDefender)?;
+			let mut defending = Defending::<T, I>::get().ok_or(Error::<T, I>::NoDefender)?;
 			let record = Members::<T, I>::get(&voter).ok_or(Error::<T, I>::NotMember)?;
 
 			DefenderVotes::<T, I>::mutate(&voter, |v| {
-				v = Some(Self::do_vote(v, approve, record.rank, &mut defending.2));
+				*v = Some(Self::do_vote(*v, approve, record.rank, &mut defending.2));
 			});
 
 			Defending::<T, I>::put(defending);
@@ -1053,14 +1044,14 @@ pub mod pallet {
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
 		pub fn payout(origin: OriginFor<T>) -> DispatchResult {
 			let who = ensure_signed(origin)?;
-			let mut record = Payouts::<T, I>::get(&who).ok_or(Error::<T, I>::NotMember)?;
+			let mut record = Payouts::<T, I>::get(&who);
 
 			if let Some((when, amount)) = record.payouts.first() {
 				if when <= &<frame_system::Pallet<T>>::block_number() {
 					record.paid = record.paid.checked_add(amount).ok_or(Overflow)?;
 					T::Currency::transfer(&Self::payouts(), &who, *amount, AllowDeath)?;
 					record.payouts.remove(0);
-					Members::<T, I>::insert(&who, record);
+					Payouts::<T, I>::insert(&who, record);
 					return Ok(())
 				}
 			}
@@ -1073,7 +1064,7 @@ pub mod pallet {
 		pub fn waive_repay(origin: OriginFor<T>) -> DispatchResult {
 			let who = ensure_signed(origin)?;
 			let mut record = Members::<T, I>::get(&who).ok_or(Error::<T, I>::NotMember)?;
-			let mut payout_record = Payouts::<T, I>::get(&who).ok_or(Error::<T, I>::NotMember)?;
+			let mut payout_record = Payouts::<T, I>::get(&who);
 			ensure!(record.rank == 0, Error::<T, I>::AlreadyElevated);
 
 			T::Currency::transfer(&who, &Self::account_id(), payout_record.paid, AllowDeath)?;
@@ -1192,8 +1183,10 @@ pub mod pallet {
 				// Try to add member back to society. Can fail with `MaxMembers` limit.
 				Self::reinstate_member(&who, record.rank)?;
 			} else {
-				let mut payout_record = Payouts::<T, I>::take(&who);
-				Self::unreserve_payout(payout_record.payouts.into_iter().map(|x| x.1).sum());
+				let payout_record = Payouts::<T, I>::take(&who);
+				let total = payout_record.payouts.into_iter()
+					.map(|x| x.1).fold(Zero::zero(), |acc: BalanceOf<T, I>, x| acc.saturating_add(x));
+				Self::unreserve_payout(total);
 			}
 
 			SuspendedMembers::<T, I>::remove(&who);
@@ -1223,7 +1216,7 @@ pub mod pallet {
 			max_strikes: u32,
 			candidate_deposit: BalanceOf<T, I>,
 		) -> DispatchResult {
-			ensure!(ensure_signed(origin)? == Founder::<T, I>::get(), Error::<T, I>::NotFounder);
+			ensure!(Some(ensure_signed(origin)?) == Founder::<T, I>::get(), Error::<T, I>::NotFounder);
 			ensure!(max_members >= MemberCount::<T, I>::get(), Error::<T, I>::MaxMembers);
 			let params = GroupParams { max_members, max_intake, max_strikes, candidate_deposit };
 			Parameters::<T, I>::put(&params);
@@ -1299,7 +1292,7 @@ pub mod pallet {
 
 /// Simple ensure origin struct to filter for the founder account.
 pub struct EnsureFounder<T>(sp_std::marker::PhantomData<T>);
-impl<T: Config> EnsureOrigin<T::Origin> for EnsureFounder<T> {
+impl<T: Config> EnsureOrigin<<T as frame_system::Config>::Origin> for EnsureFounder<T> {
 	type Success = T::AccountId;
 	fn try_origin(o: T::Origin) -> Result<Self::Success, T::Origin> {
 		o.into().and_then(|o| match (o, Founder::<T>::get()) {
@@ -1318,11 +1311,11 @@ impl<T: Config> EnsureOrigin<T::Origin> for EnsureFounder<T> {
 // TODO: Move close to `FromEntropy`?
 struct InputFromRng<'a, T>(&'a mut T);
 impl<'a, T: RngCore> codec::Input for InputFromRng<'a, T> {
-	fn remaining_len(&mut self) -> Result<Option<usize>, Error> {
+	fn remaining_len(&mut self) -> Result<Option<usize>, codec::Error> {
 		return Ok(None)
 	}
 
-	fn read(&mut self, into: &mut [u8]) -> Result<(), Error> {
+	fn read(&mut self, into: &mut [u8]) -> Result<(), codec::Error> {
 		self.0.fill_bytes(into);
 		Ok(())
 	}
@@ -1339,7 +1332,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		let claim_period = T::ClaimPeriod::get();
 		let voting_period = T::VotingPeriod::get();
 		let rotation_period = voting_period + claim_period;
-		let now = <T as frame_system::Config>::block_number();
+		let now = frame_system::Pallet::<T>::block_number();
 		let phase = now % rotation_period;
 		if phase < voting_period {
 			Period::Voting { elapsed: phase, more: voting_period - phase }
@@ -1369,15 +1362,18 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		Vote { approve, weight }
 	}
 
-	fn check_skeptic(candidate: &T::AccountId, candidacy: &Candidacy<T::AccountId, BalanceOf<T>>) {
+	fn check_skeptic(candidate: &T::AccountId, candidacy: &Candidacy<T::AccountId, BalanceOf<T, I>>) {
 		if RoundCount::<T, I>::get() != candidacy.round { return }
 		// We expect the skeptic to have voted.
-		let skeptic = Skeptic::<T, I>::get();
+		let skeptic = match Skeptic::<T, I>::get() { Some(s) => s, None => return };
 		let maybe_vote = Votes::<T, I>::get(&candidate, &skeptic);
 		let approved = candidacy.tally.more_approvals();
 		let rejected = candidacy.tally.more_rejections();
 		match (maybe_vote, approved, rejected) {
-			(None, _, _) | (Some(false), true, false) | (Some(true), false, true) => {
+			(None, _, _)
+			| (Some(Vote { approve: true, .. }), false, true)
+			| (Some(Vote { approve: false, .. }), true, false)
+			=> {
 				// Can't do much if the punishment doesn't work out.
 				let _ = Self::strike_member(&skeptic);
 			},
@@ -1397,10 +1393,14 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 			// Check defender skeptic voted and that their vote was with the majority.
 			let skeptic_vote = DefenderVotes::<T, I>::get(&skeptic);
 			match (skeptic_vote, tally.more_approvals(), tally.more_rejections()) {
-				(None, _, _) | (Some(true), false, true) | (Some(false), true, false) => {
+				(None, _, _)
+				| (Some(Vote { approve: true, .. }), false, true)
+				| (Some(Vote { approve: false, .. }), true, false)
+				=> {
 					// Punish skeptic.
 					let _ = Self::strike_member(&skeptic);
 				}
+				_ => {}
 			}
 
 			// Clean up all votes.
@@ -1412,10 +1412,10 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		// Avoid challenging if there's only two members since we never challenge the Head or
 		// the Founder.
 		if MemberCount::<T, I>::get() > 2 {
-			let defender = Self::pick_defendent(&mut rng).expect("exited if members empty; qed");
-			let skeptic = Self::pick_member_except(&mut rng, &defender).expect("exited if members empty; qed");
+			let defender = Self::pick_defendent(rng).expect("exited if members empty; qed");
+			let skeptic = Self::pick_member_except(rng, &defender).expect("exited if members empty; qed");
 			Self::deposit_event(Event::<T, I>::Challenged { member: defender.clone() });
-			Defending::<T, I>::put((defender, skeptic, 0, 0));
+			Defending::<T, I>::put((defender, skeptic, Tally::default()));
 		} else {
 			Defending::<T, I>::kill();
 		}
@@ -1429,13 +1429,13 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	/// ---------------------------------------------
 	fn rotate_intake(rng: &mut impl RngCore) {
 		// We assume there's at least one member or this logic won't work.
-		let member_count = MemberCount::get();
+		let member_count = MemberCount::<T, I>::get();
 		if member_count < 1 {
 			return
 		}
 		let maybe_head = NextHead::<T, I>::take();
 		if let Some(head) = maybe_head {
-			Head::<T, I>::put(head);
+			Head::<T, I>::put(&head.who);
 		}
 
 		// Bump the pot by at most `PeriodSpend`, but less if there's not very much left in our
@@ -1451,7 +1451,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		let candidate_count = Self::select_new_candidates(round_count, member_count, pot);
 		if candidate_count > 0 {
 			// Select a member at random and make them the skeptic for this round.
-			let skeptic = Self::pick_member(&mut rng).expect("exited if members empty; qed");
+			let skeptic = Self::pick_member(rng).expect("exited if members empty; qed");
 			Skeptic::<T, I>::put(skeptic);
 		}
 		RoundCount::<T, I>::put(round_count);
@@ -1469,13 +1469,15 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		member_count: u32,
 		pot: BalanceOf<T, I>,
 	) -> usize {
-		let max_members = Parameters::<T, I>::get().max_members as usize;
-
 		// Get the number of left-most bidders whose bids add up to less than `pot`.
 		let mut bids = Bids::<T, I>::get();
-		let mut max_selections: usize = (Parameters::<T, I>::get().max_intake as usize)
-			.min(max_members.saturating_sub(member_count))
-			.min(bids.len());
+		let params = match Parameters::<T, I>::get() {
+			Some(params) => params,
+			None => return 0,
+		};
+		let max_selections: u32 = params.max_intake
+			.min(params.max_members.saturating_sub(member_count))
+			.min(bids.len() as u32);
 
 		let mut selections = 0;
 		// A running total of the cost to onboard these bids
@@ -1490,7 +1492,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 			if accept {
 				let candidacy = Candidacy {
 					round,
-					kind: bid.kind,
+					kind: bid.kind.clone(),
 					bid: bid.value,
 					tally: Default::default(),
 				};
@@ -1501,7 +1503,8 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		});
 
 		// No need to reset Bids if we're not taking anything.
-		Bids::<T, I>::put(bids);
+		Bids::<T, I>::put(&bids);
+		bids.len()
 	}
 
 	/// Puts a bid into storage ordered by smallest to largest value.
@@ -1514,10 +1517,10 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	) {
 		let pos = bids.iter().position(|bid| bid.value > value).unwrap_or(bids.len());
 		let r = bids.force_insert_keep_left(pos, Bid { value, who: who.clone(), kind: bid_kind });
-		let maybe_discarded = r.err().or_else(|| r.ok());
+		let maybe_discarded = match r { Ok(x) => x, Err(x) => Some(x) };
 		if let Some(discarded) = maybe_discarded {
 			Self::clean_bid(&discarded);
-			Self::deposit_event(Event::<T, I>::AutoUnbid { candidate: discarded });
+			Self::deposit_event(Event::<T, I>::AutoUnbid { candidate: discarded.who });
 		}
 	}
 
@@ -1556,8 +1559,8 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	/// NOTE: Generally you should not use this, and instead use `add_new_member` or
 	/// `reinstate_member`, whose names clearly match the desired intention.
 	fn insert_member(who: &T::AccountId, rank: Rank) -> DispatchResult {
-		let params = Parameters::<T, I>::get().ok_or(Error::<T, I>::NotGroup);
-		ensure!(MemberCount::get() < params.max_members as usize, Error::<T, I>::MaxMembers);
+		let params = Parameters::<T, I>::get().ok_or(Error::<T, I>::NotGroup)?;
+		ensure!(MemberCount::<T, I>::get() < params.max_members, Error::<T, I>::MaxMembers);
 		let index = MemberCount::<T, I>::mutate(|i| { i.saturating_accrue(1); *i - 1 });
 		let record = MemberRecord { rank, strikes: 0, vouching: None, index };
 		Members::<T, I>::insert(who, record);
@@ -1584,11 +1587,11 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	/// Induct a new member into the set.
 	fn induct_member(
 		candidate: T::AccountId,
-		candidacy: Candidacy<T::AccountId, BalanceOf<T>>,
+		candidacy: Candidacy<T::AccountId, BalanceOf<T, I>>,
 		rank: Rank,
 	) -> DispatchResult {
 		Self::check_skeptic(&candidate, &candidacy);
-		Self::add_new_member(&candidate, 0)?;
+		Self::add_new_member(&candidate, rank)?;
 		let next_head = NextHead::<T, I>::get()
 			.filter(|old| old.round > candidacy.round
 				|| old.round == candidacy.round && old.bid < candidacy.bid
@@ -1603,11 +1606,12 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	}
 
 	fn strike_member(who: &T::AccountId) -> DispatchResult {
-		let mut record = Members::<T, I>::get(who).ok_or(NotMember)?;
+		let mut record = Members::<T, I>::get(who).ok_or(Error::<T, I>::NotMember)?;
 		record.strikes.saturating_inc();
 		if record.strikes >= T::GraceStrikes::get() {
 			// Too many strikes: slash the payout in half.
-			let total_payout = record.payouts.iter().map(|x| x.1).sum();
+			let total_payout = Payouts::<T, I>::get(who).payouts.iter()
+				.fold(BalanceOf::<T, I>::zero(), |acc, x| acc.saturating_add(x.1));
 			Self::slash_payout(who, total_payout / 2u32.into());
 		}
 		let params = Parameters::<T, I>::get().ok_or(Error::<T, I>::NotGroup)?;
@@ -1631,13 +1635,13 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	pub fn remove_member(m: &T::AccountId) -> Result<MemberRecord, DispatchError> {
 		ensure!(Head::<T, I>::get().as_ref() != Some(m), Error::<T, I>::Head);
 		ensure!(Founder::<T, I>::get().as_ref() != Some(m), Error::<T, I>::Founder);
-		if let Some(record) = Members::<T, I>::get(m) {
+		if let Some(mut record) = Members::<T, I>::get(m) {
 			let index = record.index;
 			let last_index = MemberCount::<T, I>::mutate(|i| { i.saturating_reduce(1); *i });
 			if index != last_index {
 				// Move the member with the last index down to the index of the member to be removed.
 				if let Some(other) = MemberByIndex::<T, I>::get(last_index) {
-					MemberByIndex::<T, I>::insert(index, other);
+					MemberByIndex::<T, I>::insert(index, &other);
 					Members::<T, I>::mutate(other, |m_r|
 						if let Some(r) = m_r { r.index = index }
 					);
@@ -1654,7 +1658,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 				// If their vouch is already a candidate, do nothing.
 				Bids::<T, I>::mutate(|bids|
 					// Try to find the matching bid
-					if let Some(pos) = bids.iter().position(|b| b.kind.check_voucher(&who).is_ok()) {
+					if let Some(pos) = bids.iter().position(|b| b.kind.is_vouch(&m)) {
 						// Remove the bid, and emit an event
 						let vouched = bids.remove(pos).who;
 						Self::deposit_event(Event::<T, I>::Unvouch { candidate: vouched });
@@ -1683,7 +1687,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	///
 	/// If no members exist (or the state is inconsistent), then `None` may be returned.
 	fn pick_member(rng: &mut impl RngCore) -> Option<T::AccountId> {
-		let member_count = MemberCount::get();
+		let member_count = MemberCount::<T, I>::get();
 		if member_count == 0 {
 			return None
 		}
@@ -1695,7 +1699,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	///
 	/// If `exception` is the only member (or the state is inconsistent), then `None` may be returned.
 	fn pick_member_except(rng: &mut impl RngCore, exception: &T::AccountId) -> Option<T::AccountId> {
-		let member_count = MemberCount::get();
+		let member_count = MemberCount::<T, I>::get();
 		if member_count <= 1 {
 			return None
 		}
@@ -1713,7 +1717,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	/// If only the Founder and Head members exist (or the state is inconsistent), then `None`
 	/// may be returned.
 	fn pick_defendent(rng: &mut impl RngCore) -> Option<T::AccountId> {
-		let member_count = MemberCount::get();
+		let member_count = MemberCount::<T, I>::get();
 		if member_count <= 2 {
 			return None
 		}
@@ -1751,11 +1755,17 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 			BidKind::Vouch(voucher, tip) => {
 				// Check that the voucher is still vouching, else some other logic may have removed
 				// their status.
-				if Vouching::<T, I>::take(&voucher) == Some(VouchingStatus::Vouching) {
-					// In the case that a vouched-for bid is accepted we unset the
-					// vouching status and transfer the tip over to the voucher.
-					Self::bump_payout(&voucher, maturity, tip.min(value));
-					value.saturating_sub(tip)
+				if let Some(mut record) = Members::<T, I>::get(&voucher) {
+					if let Some(VouchingStatus::Vouching) = record.vouching {
+						// In the case that a vouched-for bid is accepted we unset the
+						// vouching status and transfer the tip over to the voucher.
+						record.vouching = None;
+						Self::bump_payout(&voucher, maturity, tip.min(value));
+						Members::<T, I>::insert(&voucher, record);
+						value.saturating_sub(tip)
+					} else {
+						value
+					}
 				} else {
 					value
 				}
@@ -1771,25 +1781,25 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	/// is not a member or if `value` is zero.
 	fn bump_payout(who: &T::AccountId, when: T::BlockNumber, value: BalanceOf<T, I>) {
 		if !value.is_zero() {
-			Members::<T, I>::mutate(who, |maybe_record| if let Some(record) = maybe_record {
-				if record.rank == 0 {
+			if let Some(MemberRecord { rank: 0, .. }) = Members::<T, I>::get(who) {
+				Payouts::<T, I>::mutate_extant(who, |record| {
 					// Members of rank 1 never get payouts.
 					match record.payouts.binary_search_by_key(&when, |x| x.0) {
 						Ok(index) => record.payouts[index].1.saturating_accrue(value),
-						Err(index) => record.payouts.insert(index, (when, value)),
+						Err(index) => {
+							// If they have too many pending payouts, then we take discard the payment.
+							let _ = record.payouts.try_insert(index, (when, value));
+						},
 					}
-				}
-			});
-			Self::reserve_payout(value);
+				});
+				Self::reserve_payout(value);
+			}
 		}
 	}
 
 	/// Attempt to slash the payout of some member. Return the total amount that was deducted.
 	fn slash_payout(who: &T::AccountId, value: BalanceOf<T, I>) -> BalanceOf<T, I> {
-		let mut record = match Members::<T, I>::get(who) {
-			Some(record) => record,
-			None => return Zero::zero(),
-		};
+		let mut record = Payouts::<T, I>::get(who);
 		let mut rest = value;
 		while !record.payouts.is_empty() {
 			if let Some(new_rest) = rest.checked_sub(&record.payouts[0].1) {
@@ -1803,13 +1813,13 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 				break
 			}
 		}
-		Members::<T, I>::insert(who, record);
+		Payouts::<T, I>::insert(who, record);
 		value - rest
 	}
 
 	/// Transfer some `amount` from the main account into the payouts account and reduce the Pot
 	/// by this amount.
-	fn reserve_payout(amount: BalanceOf<T>) {
+	fn reserve_payout(amount: BalanceOf<T, I>) {
 		// Tramsfer payout from the Pot into the payouts account.
 		Pot::<T, I>::mutate(|pot| pot.saturating_reduce(amount));
 
@@ -1826,7 +1836,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 
 	/// Transfer some `amount` from the main account into the payouts account and increase the Pot
 	/// by this amount.
-	fn unreserve_payout(amount: BalanceOf<T>) {
+	fn unreserve_payout(amount: BalanceOf<T, I>) {
 		// Tramsfer payout from the Pot into the payouts account.
 		Pot::<T, I>::mutate(|pot| pot.saturating_accrue(amount));
 
diff --git a/frame/support/src/storage/bounded_vec.rs b/frame/support/src/storage/bounded_vec.rs
index 5795edde24bc2..1f0ac9d019259 100644
--- a/frame/support/src/storage/bounded_vec.rs
+++ b/frame/support/src/storage/bounded_vec.rs
@@ -105,7 +105,7 @@ impl<T: Encode + Decode, S: Get<u32>> EncodeLike<Vec<T>> for BoundedVec<T, S> {}
 
 impl<T, S> BoundedVec<T, S> {
 	/// Create `Self` with no items.
-	fn new() -> Self {
+	pub fn new() -> Self {
 		Self(Vec::new(), Default::default())
 	}
 
@@ -144,6 +144,11 @@ impl<T, S> BoundedVec<T, S> {
 		self.0.sort()
 	}
 
+	/// Exactly the same semantics as `Vec::clear`.
+	pub fn clear(&mut self) {
+		self.0.clear()
+	}
+
 	/// Exactly the same semantics as `Vec::remove`.
 	///
 	/// # Panics
diff --git a/frame/support/src/storage/types/map.rs b/frame/support/src/storage/types/map.rs
index e786c1fd4357d..80250dbc60796 100644
--- a/frame/support/src/storage/types/map.rs
+++ b/frame/support/src/storage/types/map.rs
@@ -166,7 +166,7 @@ where
 	}
 
 	/// Mutate the value under a key iff it exists. Do nothing and return the default value if not.
-	pub fn mutate_extant<KeyArg: EncodeLike<Key>, R, F: FnOnce(&mut Value) -> R>(
+	pub fn mutate_extant<KeyArg: EncodeLike<Key>, R: Default, F: FnOnce(&mut Value) -> R>(
 		key: KeyArg,
 		f: F,
 	) -> R {
diff --git a/primitives/core/src/ecdsa.rs b/primitives/core/src/ecdsa.rs
index ebb70e74e758d..bf6bf33e9a95c 100644
--- a/primitives/core/src/ecdsa.rs
+++ b/primitives/core/src/ecdsa.rs
@@ -74,8 +74,8 @@ type Seed = [u8; 32];
 )]
 pub struct Public(pub [u8; 33]);
 
-impl FromEntropy for Public {
-	fn from_entropy(input: &mut codec::Input) -> Result<Self, codec::Error> {
+impl crate::traits::FromEntropy for Public {
+	fn from_entropy(input: &mut impl codec::Input) -> Result<Self, codec::Error> {
 		let mut result = Self([0u8; 33]);
 		input.read(&mut result.0[..])?;
 		Ok(result)
diff --git a/primitives/core/src/ed25519.rs b/primitives/core/src/ed25519.rs
index bbb1ab74587e5..d735d8db826e4 100644
--- a/primitives/core/src/ed25519.rs
+++ b/primitives/core/src/ed25519.rs
@@ -88,8 +88,8 @@ impl Clone for Pair {
 	}
 }
 
-impl FromEntropy for Public {
-	fn from_entropy(input: &mut codec::Input) -> Result<Self, codec::Error> {
+impl crate::traits::FromEntropy for Public {
+	fn from_entropy(input: &mut impl codec::Input) -> Result<Self, codec::Error> {
 		let mut result = Self([0u8; 32]);
 		input.read(&mut result.0[..])?;
 		Ok(result)
diff --git a/primitives/core/src/sr25519.rs b/primitives/core/src/sr25519.rs
index 4e72f747a3a4e..251776c5e8118 100644
--- a/primitives/core/src/sr25519.rs
+++ b/primitives/core/src/sr25519.rs
@@ -94,7 +94,7 @@ impl Clone for Pair {
 }
 
 impl FromEntropy for Public {
-	fn from_entropy(input: &mut codec::Input) -> Result<Self, codec::Error> {
+	fn from_entropy(input: &mut impl codec::Input) -> Result<Self, codec::Error> {
 		let mut result = Self([0u8; 32]);
 		input.read(&mut result.0[..])?;
 		Ok(result)
diff --git a/primitives/core/src/traits.rs b/primitives/core/src/traits.rs
index 9ba35dd402548..a799e3285fe5d 100644
--- a/primitives/core/src/traits.rs
+++ b/primitives/core/src/traits.rs
@@ -280,8 +280,8 @@ impl SpawnEssentialNamed for Box<dyn SpawnEssentialNamed> {
 }
 
 /// Create random values of `Self` given a stream of entropy.
-pub trait FromEntropy {
+pub trait FromEntropy: Sized {
 	/// Create a random value of `Self` given a stream of random bytes on `input`. May only fail if
 	/// `input` has an error.
-	fn from_entropy(input: &mut codec::Input) -> Result<Self, codec::Error>;
+	fn from_entropy(input: &mut impl codec::Input) -> Result<Self, codec::Error>;
 }
diff --git a/primitives/runtime/src/lib.rs b/primitives/runtime/src/lib.rs
index e420a8a42377f..11af6b37d9a67 100644
--- a/primitives/runtime/src/lib.rs
+++ b/primitives/runtime/src/lib.rs
@@ -170,7 +170,7 @@ impl From<Justification> for Justifications {
 	}
 }
 
-use traits::{Lazy, Verify, FromEntropy};
+use traits::{Lazy, Verify};
 
 use crate::traits::IdentifyAccount;
 #[cfg(feature = "std")]
@@ -304,11 +304,11 @@ pub enum MultiSigner {
 }
 
 impl FromEntropy for MultiSigner {
-	fn from_entropy(input: &mut codec::Input) -> Result<Self, ()> {
-		Ok(match input.read_byte() % 3 {
-			0 => Self::Ed25519(FromEntropy::try_from_entropy(input)?),
-			1 => Self::Sr25519(FromEntropy::try_from_entropy(input)?),
-			2.. => Self::Ecdsa(FromEntropy::try_from_entropy(input)?),
+	fn from_entropy(input: &mut impl codec::Input) -> Result<Self, codec::Error> {
+		Ok(match input.read_byte()? % 3 {
+			0 => Self::Ed25519(FromEntropy::from_entropy(input)?),
+			1 => Self::Sr25519(FromEntropy::from_entropy(input)?),
+			2.. => Self::Ecdsa(FromEntropy::from_entropy(input)?),
 		})
 	}
 }

From feb7d6b66dafefdd98ecc7aac1cb46b9ebe75185 Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@parity.io>
Date: Tue, 3 May 2022 18:19:36 +0100
Subject: [PATCH 05/43] Some tests

---
 frame/society/src/lib.rs      |  10 +-
 frame/society/src/mock.rs     |  65 +++++------
 frame/society/src/tests.rs    | 210 +++++++++++++++++++---------------
 primitives/core/src/traits.rs |  39 +++++++
 4 files changed, 183 insertions(+), 141 deletions(-)

diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index 9d5a143f88380..e11d7982bec1d 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -1125,18 +1125,12 @@ pub mod pallet {
 		/// the `Founder` and the `Head`. This implies that it may only be done when there is one
 		/// member.
 		///
-		/// # <weight>
-		/// - Two storage reads O(1).
-		/// - Four storage removals O(1).
-		/// - One event.
-		///
 		/// Total Complexity: O(1)
-		/// # </weight>
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
 		pub fn dissolve(origin: OriginFor<T>) -> DispatchResult {
 			let founder = ensure_signed(origin)?;
-			ensure!(Founder::<T, I>::get() == Some(founder.clone()), Error::<T, I>::NotFounder);
-			ensure!(Head::<T, I>::get() == Some(founder.clone()), Error::<T, I>::NotHead);
+			ensure!(Founder::<T, I>::get().as_ref() == Some(&founder), Error::<T, I>::NotFounder);
+			ensure!(MemberCount::<T, I>::get() == 1, Error::<T, I>::NotHead);
 
 			Members::<T, I>::remove_all(None);
 			MemberCount::<T, I>::kill();
diff --git a/frame/society/src/mock.rs b/frame/society/src/mock.rs
index 3c84a3f66a39e..dc41295fe7645 100644
--- a/frame/society/src/mock.rs
+++ b/frame/society/src/mock.rs
@@ -99,34 +99,30 @@ impl pallet_balances::Config for Test {
 
 impl Config for Test {
 	type Event = Event;
+	type PalletId = SocietyPalletId;
 	type Currency = pallet_balances::Pallet<Self>;
 	type Randomness = TestRandomness<Self>;
-	type CandidateDeposit = ConstU64<25>;
-	type WrongSideDeduction = ConstU64<2>;
-	type MaxStrikes = ConstU32<2>;
+	type GraceStrikes = ConstU32<1>;
 	type PeriodSpend = ConstU64<1000>;
-	type MembershipChanged = ();
-	type RotationPeriod = ConstU64<4>;
+	type VotingPeriod = ConstU64<3>;
+	type ClaimPeriod = ConstU64<1>;
 	type MaxLockDuration = ConstU64<100>;
 	type FounderSetOrigin = EnsureSignedBy<FounderSetAccount, u128>;
-	type JudgementOrigin = EnsureSignedBy<SuspensionJudgementSetAccount, u128>;
 	type ChallengePeriod = ConstU64<8>;
-	type MaxCandidateIntake = ConstU32<10>;
-	type PalletId = SocietyPalletId;
+	type MaxPayouts = ConstU32<10>;
+	type MaxBids = ConstU32<10>;
 }
 
 pub struct EnvBuilder {
-	members: Vec<u128>,
 	balance: u64,
 	balances: Vec<(u128, u64)>,
 	pot: u64,
-	max_members: u32,
+	founded: bool,
 }
 
 impl EnvBuilder {
 	pub fn new() -> Self {
 		Self {
-			members: vec![10],
 			balance: 10_000,
 			balances: vec![
 				(10, 50),
@@ -140,7 +136,7 @@ impl EnvBuilder {
 				(90, 50),
 			],
 			pot: 0,
-			max_members: 100,
+			founded: true,
 		}
 	}
 
@@ -151,38 +147,18 @@ impl EnvBuilder {
 			.assimilate_storage(&mut t)
 			.unwrap();
 		pallet_society::GenesisConfig::<Test> {
-			members: self.members,
 			pot: self.pot,
-			max_members: self.max_members,
 		}
 		.assimilate_storage(&mut t)
 		.unwrap();
 		let mut ext: sp_io::TestExternalities = t.into();
-		ext.execute_with(f)
-	}
-	#[allow(dead_code)]
-	pub fn with_members(mut self, m: Vec<u128>) -> Self {
-		self.members = m;
-		self
+		ext.execute_with(|| {
+			assert!(Society::found_society(Origin::signed(1), 10, 100, 10, 2, 25, b"be cool".to_vec()).is_ok());
+			f()
+		})
 	}
-	#[allow(dead_code)]
-	pub fn with_balances(mut self, b: Vec<(u128, u64)>) -> Self {
-		self.balances = b;
-		self
-	}
-	#[allow(dead_code)]
-	pub fn with_pot(mut self, p: u64) -> Self {
-		self.pot = p;
-		self
-	}
-	#[allow(dead_code)]
-	pub fn with_balance(mut self, b: u64) -> Self {
-		self.balance = b;
-		self
-	}
-	#[allow(dead_code)]
-	pub fn with_max_members(mut self, n: u32) -> Self {
-		self.max_members = n;
+	pub fn founded(mut self, f: bool) -> Self {
+		self.founded = f;
 		self
 	}
 }
@@ -198,7 +174,7 @@ pub fn run_to_block(n: u64) {
 		Society::on_initialize(System::block_number());
 	}
 }
-
+/*
 /// Creates a bid struct using input parameters.
 pub fn create_bid<AccountId, Balance>(
 	value: Balance,
@@ -207,3 +183,14 @@ pub fn create_bid<AccountId, Balance>(
 ) -> Bid<AccountId, Balance> {
 	Bid { who, kind, value }
 }
+*/
+/// Creates a candidate struct using input parameters.
+pub fn candidacy<AccountId, Balance>(
+	round: RoundIndex,
+	bid: Balance,
+	kind: BidKind<AccountId, Balance>,
+	approvals: VoteCount,
+	rejections: VoteCount,
+) -> Candidacy<AccountId, Balance> {
+	Candidacy { round, kind, bid, tally: Tally { approvals, rejections } }
+}
diff --git a/frame/society/src/tests.rs b/frame/society/src/tests.rs
index d394ddc9011b0..55e36cc542c90 100644
--- a/frame/society/src/tests.rs
+++ b/frame/society/src/tests.rs
@@ -24,34 +24,44 @@ use frame_support::{assert_noop, assert_ok};
 use sp_core::blake2_256;
 use sp_runtime::traits::BadOrigin;
 
+fn members() -> Vec<u128> {
+	let mut r = Members::<Test>::iter_keys().collect::<Vec<_>>();
+	r.sort();
+	r
+}
+
+fn candidates() -> Vec<(u128, Candidacy<u128, u64>)> {
+	Candidates::<Test>::iter().collect()
+}
+
 #[test]
 fn founding_works() {
-	EnvBuilder::new().with_max_members(0).with_members(vec![]).execute(|| {
+	EnvBuilder::new().founded(false).execute(|| {
 		// Not set up initially.
-		assert_eq!(Society::founder(), None);
-		assert_eq!(Society::max_members(), 0);
-		assert_eq!(Society::pot(), 0);
+		assert_eq!(Founder::<Test>::get(), None);
+		assert_eq!(Parameters::<Test>::get(), None);
+		assert_eq!(Pot::<Test>::get(), 0);
 		// Account 1 is set as the founder origin
 		// Account 5 cannot start a society
-		assert_noop!(Society::found(Origin::signed(5), 20, 100, vec![]), BadOrigin);
+		assert_noop!(Society::found_society(Origin::signed(5), 20, 100, 10, 2, 25, vec![]), BadOrigin);
 		// Account 1 can start a society, where 10 is the founding member
-		assert_ok!(Society::found(Origin::signed(1), 10, 100, b"be cool".to_vec()));
+		assert_ok!(Society::found_society(Origin::signed(1), 10, 100, 10, 2, 25, b"be cool".to_vec()));
 		// Society members only include 10
-		assert_eq!(Society::members(), vec![10]);
+		assert_eq!(members(), vec![10]);
 		// 10 is the head of the society
-		assert_eq!(Society::head(), Some(10));
+		assert_eq!(Head::<Test>::get(), Some(10));
 		// ...and also the founder
-		assert_eq!(Society::founder(), Some(10));
+		assert_eq!(Founder::<Test>::get(), Some(10));
 		// 100 members max
-		assert_eq!(Society::max_members(), 100);
+		assert_eq!(Parameters::<Test>::get().unwrap().max_members, 100);
 		// rules are correct
-		assert_eq!(Society::rules(), Some(blake2_256(b"be cool").into()));
+		assert_eq!(Rules::<Test>::get(), Some(blake2_256(b"be cool").into()));
 		// Pot grows after first rotation period
 		run_to_block(4);
-		assert_eq!(Society::pot(), 1000);
+		assert_eq!(Pot::<Test>::get(), 1000);
 		// Cannot start another society
 		assert_noop!(
-			Society::found(Origin::signed(1), 20, 100, vec![]),
+			Society::found_society(Origin::signed(1), 20, 100, 10, 2, 25, vec![]),
 			Error::<Test, _>::AlreadyFounded
 		);
 	});
@@ -59,24 +69,25 @@ fn founding_works() {
 
 #[test]
 fn unfounding_works() {
-	EnvBuilder::new().with_max_members(0).with_members(vec![]).execute(|| {
+	EnvBuilder::new().founded(false).execute(|| {
 		// Account 1 sets the founder...
-		assert_ok!(Society::found(Origin::signed(1), 10, 100, vec![]));
+		assert_ok!(Society::found_society(Origin::signed(1), 10, 100, 10, 2, 25, vec![]));
 		// Account 2 cannot unfound it as it's not the founder.
-		assert_noop!(Society::unfound(Origin::signed(2)), Error::<Test, _>::NotFounder);
+		assert_noop!(Society::dissolve(Origin::signed(2)), Error::<Test, _>::NotFounder);
 		// Account 10 can, though.
-		assert_ok!(Society::unfound(Origin::signed(10)));
+		assert_ok!(Society::dissolve(Origin::signed(10)));
 
 		// 1 sets the founder to 20 this time
-		assert_ok!(Society::found(Origin::signed(1), 20, 100, vec![]));
+		assert_ok!(Society::found_society(Origin::signed(1), 20, 100, 10, 2, 25, vec![]));
 		// Bring in a new member...
 		assert_ok!(Society::bid(Origin::signed(10), 0));
 		run_to_block(4);
 		assert_ok!(Society::vote(Origin::signed(20), 10, true));
-		run_to_block(8);
+		run_to_block(7);
+		assert_ok!(Society::claim_membership(Origin::signed(10)));
 
 		// Unfounding won't work now, even though it's from 20.
-		assert_noop!(Society::unfound(Origin::signed(20)), Error::<Test, _>::NotHead);
+		assert_noop!(Society::dissolve(Origin::signed(20)), Error::<Test, _>::NotHead);
 	});
 }
 
@@ -91,13 +102,15 @@ fn basic_new_member_works() {
 		// Rotate period every 4 blocks
 		run_to_block(4);
 		// 20 is now a candidate
-		assert_eq!(Society::candidates(), vec![create_bid(0, 20, BidKind::Deposit(25))]);
+		assert_eq!(candidates(), vec![(20, candidacy(1, 0, BidKind::Deposit(25), 0, 0))]);
 		// 10 (a member) can vote for the candidate
 		assert_ok!(Society::vote(Origin::signed(10), 20, true));
 		// Rotate period every 4 blocks
+		run_to_block(7);
+		assert_ok!(Society::claim_membership(Origin::signed(20)));
 		run_to_block(8);
 		// 20 is now a member of the society
-		assert_eq!(Society::members(), vec![10, 20]);
+		assert_eq!(members(), vec![10, 20]);
 		// Reserved balance is returned
 		assert_eq!(Balances::free_balance(20), 50);
 		assert_eq!(Balances::reserved_balance(20), 0);
@@ -115,55 +128,62 @@ fn bidding_works() {
 		// Rotate period
 		run_to_block(4);
 		// Pot is 1000 after "PeriodSpend"
-		assert_eq!(Society::pot(), 1000);
+		assert_eq!(Pot::<Test>::get(), 1000);
 		assert_eq!(Balances::free_balance(Society::account_id()), 10_000);
 		// Choose smallest bidding users whose total is less than pot
 		assert_eq!(
-			Society::candidates(),
+			candidates(),
 			vec![
-				create_bid(300, 30, BidKind::Deposit(25)),
-				create_bid(400, 40, BidKind::Deposit(25)),
+				(30, candidacy(1, 300, BidKind::Deposit(25), 0, 0)),
+				(40, candidacy(1, 400, BidKind::Deposit(25), 0, 0)),
 			]
 		);
 		// A member votes for these candidates to join the society
 		assert_ok!(Society::vote(Origin::signed(10), 30, true));
 		assert_ok!(Society::vote(Origin::signed(10), 40, true));
+		run_to_block(7);
+		assert_ok!(Society::claim_membership(Origin::signed(30)));
+		assert_ok!(Society::claim_membership(Origin::signed(40)));
 		run_to_block(8);
 		// Candidates become members after a period rotation
-		assert_eq!(Society::members(), vec![10, 30, 40]);
+		assert_eq!(members(), vec![10, 30, 40]);
 		// Pot is increased by 1000, but pays out 700 to the members
 		assert_eq!(Balances::free_balance(Society::account_id()), 9_300);
-		assert_eq!(Society::pot(), 1_300);
+		assert_eq!(Pot::<Test>::get(), 1_300);
 		// Left over from the original bids is 50 who satisfies the condition of bid less than pot.
-		assert_eq!(Society::candidates(), vec![create_bid(500, 50, BidKind::Deposit(25))]);
+		assert_eq!(candidates(), vec![(50, candidacy(2, 500, BidKind::Deposit(25), 0, 0))]);
 		// 40, now a member, can vote for 50
 		assert_ok!(Society::vote(Origin::signed(40), 50, true));
+		run_to_block(11);
+		assert_ok!(Society::claim_membership(Origin::signed(50)));
 		run_to_block(12);
 		// 50 is now a member
-		assert_eq!(Society::members(), vec![10, 30, 40, 50]);
+		assert_eq!(members(), vec![10, 30, 40, 50]);
 		// Pot is increased by 1000, and 500 is paid out. Total payout so far is 1200.
-		assert_eq!(Society::pot(), 1_800);
+		assert_eq!(Pot::<Test>::get(), 1_800);
 		assert_eq!(Balances::free_balance(Society::account_id()), 8_800);
 		// No more candidates satisfy the requirements
-		assert_eq!(Society::candidates(), vec![]);
+		assert_eq!(candidates(), vec![]);
 		assert_ok!(Society::defender_vote(Origin::signed(10), true)); // Keep defender around
-															  // Next period
+		// Next period
 		run_to_block(16);
 		// Same members
-		assert_eq!(Society::members(), vec![10, 30, 40, 50]);
+		assert_eq!(members(), vec![10, 30, 40, 50]);
 		// Pot is increased by 1000 again
-		assert_eq!(Society::pot(), 2_800);
+		assert_eq!(Pot::<Test>::get(), 2_800);
 		// No payouts
 		assert_eq!(Balances::free_balance(Society::account_id()), 8_800);
 		// Candidate 60 now qualifies based on the increased pot size.
-		assert_eq!(Society::candidates(), vec![create_bid(1900, 60, BidKind::Deposit(25))]);
+		assert_eq!(candidates(), vec![(60, candidacy(4, 1900, BidKind::Deposit(25), 0, 0))]);
 		// Candidate 60 is voted in.
 		assert_ok!(Society::vote(Origin::signed(50), 60, true));
+		run_to_block(19);
+		assert_ok!(Society::claim_membership(Origin::signed(60)));
 		run_to_block(20);
 		// 60 joins as a member
-		assert_eq!(Society::members(), vec![10, 30, 40, 50, 60]);
+		assert_eq!(members(), vec![10, 30, 40, 50, 60]);
 		// Pay them
-		assert_eq!(Society::pot(), 1_900);
+		assert_eq!(Pot::<Test>::get(), 1_900);
 		assert_eq!(Balances::free_balance(Society::account_id()), 6_900);
 	});
 }
@@ -186,10 +206,11 @@ fn unbidding_works() {
 		assert_eq!(Balances::reserved_balance(30), 0);
 		// 20 wins candidacy
 		run_to_block(4);
-		assert_eq!(Society::candidates(), vec![create_bid(1000, 20, BidKind::Deposit(25))]);
+		assert_eq!(candidates(), vec![create_bid(1000, 20, BidKind::Deposit(25))]);
 	});
 }
 
+/*
 #[test]
 fn payout_works() {
 	EnvBuilder::new().execute(|| {
@@ -214,9 +235,9 @@ fn basic_new_member_skeptic_works() {
 		assert_eq!(Strikes::<Test>::get(10), 0);
 		assert_ok!(Society::bid(Origin::signed(20), 0));
 		run_to_block(4);
-		assert_eq!(Society::candidates(), vec![create_bid(0, 20, BidKind::Deposit(25))]);
+		assert_eq!(candidates(), vec![create_bid(0, 20, BidKind::Deposit(25))]);
 		run_to_block(8);
-		assert_eq!(Society::members(), vec![10]);
+		assert_eq!(members(), vec![10]);
 		assert_eq!(Strikes::<Test>::get(10), 1);
 	});
 }
@@ -232,14 +253,14 @@ fn basic_new_member_reject_works() {
 		assert_eq!(Balances::reserved_balance(20), 25);
 		// Rotation Period
 		run_to_block(4);
-		assert_eq!(Society::candidates(), vec![create_bid(0, 20, BidKind::Deposit(25))]);
+		assert_eq!(candidates(), vec![create_bid(0, 20, BidKind::Deposit(25))]);
 		// We say no
 		assert_ok!(Society::vote(Origin::signed(10), 20, false));
 		run_to_block(8);
 		// User is not added as member
-		assert_eq!(Society::members(), vec![10]);
+		assert_eq!(members(), vec![10]);
 		// User is suspended
-		assert_eq!(Society::candidates(), vec![]);
+		assert_eq!(candidates(), vec![]);
 		assert_eq!(Society::suspended_candidate(20).is_some(), true);
 	});
 }
@@ -342,14 +363,14 @@ fn suspended_candidate_rejected_works() {
 		assert_eq!(Balances::reserved_balance(20), 25);
 		// Rotation Period
 		run_to_block(4);
-		assert_eq!(Society::candidates(), vec![create_bid(0, 20, BidKind::Deposit(25))]);
+		assert_eq!(candidates(), vec![create_bid(0, 20, BidKind::Deposit(25))]);
 		// We say no
 		assert_ok!(Society::vote(Origin::signed(10), 20, false));
 		run_to_block(8);
 		// User is not added as member
-		assert_eq!(Society::members(), vec![10]);
+		assert_eq!(members(), vec![10]);
 		// User is suspended
-		assert_eq!(Society::candidates(), vec![]);
+		assert_eq!(candidates(), vec![]);
 		assert_eq!(Society::suspended_candidate(20).is_some(), true);
 
 		// Normal user cannot make judgement on suspended candidate
@@ -363,14 +384,14 @@ fn suspended_candidate_rejected_works() {
 		// They are placed back in bid pool, repeat suspension process
 		// Rotation Period
 		run_to_block(12);
-		assert_eq!(Society::candidates(), vec![create_bid(0, 20, BidKind::Deposit(25))]);
+		assert_eq!(candidates(), vec![create_bid(0, 20, BidKind::Deposit(25))]);
 		// We say no
 		assert_ok!(Society::vote(Origin::signed(10), 20, false));
 		run_to_block(16);
 		// User is not added as member
-		assert_eq!(Society::members(), vec![10]);
+		assert_eq!(members(), vec![10]);
 		// User is suspended
-		assert_eq!(Society::candidates(), vec![]);
+		assert_eq!(candidates(), vec![]);
 		assert_eq!(Society::suspended_candidate(20).is_some(), true);
 
 		// Suspension judgement origin rejects the candidate
@@ -381,7 +402,7 @@ fn suspended_candidate_rejected_works() {
 		// Funds are deposited to society account
 		assert_eq!(Balances::free_balance(Society::account_id()), 10025);
 		// Cleaned up
-		assert_eq!(Society::candidates(), vec![]);
+		assert_eq!(candidates(), vec![]);
 		assert_eq!(<SuspendedCandidates<Test>>::get(20), None);
 	});
 }
@@ -390,7 +411,7 @@ fn suspended_candidate_rejected_works() {
 fn vouch_works() {
 	EnvBuilder::new().execute(|| {
 		// 10 is the only member
-		assert_eq!(Society::members(), vec![10]);
+		assert_eq!(members(), vec![10]);
 		// A non-member cannot vouch
 		assert_noop!(Society::vouch(Origin::signed(1), 20, 1000, 100), Error::<Test, _>::NotMember);
 		// A member can though
@@ -405,12 +426,12 @@ fn vouch_works() {
 		assert_eq!(<Bids<Test>>::get(), vec![create_bid(1000, 20, BidKind::Vouch(10, 100))]);
 		// Vouched user can become candidate
 		run_to_block(4);
-		assert_eq!(Society::candidates(), vec![create_bid(1000, 20, BidKind::Vouch(10, 100))]);
+		assert_eq!(candidates(), vec![create_bid(1000, 20, BidKind::Vouch(10, 100))]);
 		// Vote yes
 		assert_ok!(Society::vote(Origin::signed(10), 20, true));
 		// Vouched user can win
 		run_to_block(8);
-		assert_eq!(Society::members(), vec![10, 20]);
+		assert_eq!(members(), vec![10, 20]);
 		// Voucher wins a portion of the payment
 		assert_eq!(<Payouts<Test>>::get(10), vec![(9, 100)]);
 		// Vouched user wins the rest
@@ -424,19 +445,19 @@ fn vouch_works() {
 fn voucher_cannot_win_more_than_bid() {
 	EnvBuilder::new().execute(|| {
 		// 10 is the only member
-		assert_eq!(Society::members(), vec![10]);
+		assert_eq!(members(), vec![10]);
 		// 10 vouches, but asks for more than the bid
 		assert_ok!(Society::vouch(Origin::signed(10), 20, 100, 1000));
 		// Vouching creates the right kind of bid
 		assert_eq!(<Bids<Test>>::get(), vec![create_bid(100, 20, BidKind::Vouch(10, 1000))]);
 		// Vouched user can become candidate
 		run_to_block(4);
-		assert_eq!(Society::candidates(), vec![create_bid(100, 20, BidKind::Vouch(10, 1000))]);
+		assert_eq!(candidates(), vec![create_bid(100, 20, BidKind::Vouch(10, 1000))]);
 		// Vote yes
 		assert_ok!(Society::vote(Origin::signed(10), 20, true));
 		// Vouched user can win
 		run_to_block(8);
-		assert_eq!(Society::members(), vec![10, 20]);
+		assert_eq!(members(), vec![10, 20]);
 		// Voucher wins as much as the bid
 		assert_eq!(<Payouts<Test>>::get(10), vec![(9, 100)]);
 		// Vouched user gets nothing
@@ -448,7 +469,7 @@ fn voucher_cannot_win_more_than_bid() {
 fn unvouch_works() {
 	EnvBuilder::new().execute(|| {
 		// 10 is the only member
-		assert_eq!(Society::members(), vec![10]);
+		assert_eq!(members(), vec![10]);
 		// 10 vouches for 20
 		assert_ok!(Society::vouch(Origin::signed(10), 20, 100, 0));
 		// 20 has a bid
@@ -467,21 +488,21 @@ fn unvouch_works() {
 		// Cannot unvouch after they become candidate
 		assert_ok!(Society::vouch(Origin::signed(10), 20, 100, 0));
 		run_to_block(4);
-		assert_eq!(Society::candidates(), vec![create_bid(100, 20, BidKind::Vouch(10, 0))]);
+		assert_eq!(candidates(), vec![create_bid(100, 20, BidKind::Vouch(10, 0))]);
 		assert_noop!(Society::unvouch(Origin::signed(10), 0), Error::<Test, _>::BadPosition);
 		// 10 is still vouching until candidate is approved or rejected
 		assert_eq!(<Vouching<Test>>::get(10), Some(VouchingStatus::Vouching));
 		run_to_block(8);
 		// In this case candidate is denied and suspended
 		assert!(Society::suspended_candidate(&20).is_some());
-		assert_eq!(Society::members(), vec![10]);
+		assert_eq!(members(), vec![10]);
 		// User is stuck vouching until judgement origin resolves suspended candidate
 		assert_eq!(<Vouching<Test, _>>::get(10), Some(VouchingStatus::Vouching));
 		// Judge denies candidate
 		assert_ok!(Society::judge_suspended_candidate(Origin::signed(2), 20, Judgement::Reject));
 		// 10 is banned from vouching
 		assert_eq!(<Vouching<Test, _>>::get(10), Some(VouchingStatus::Banned));
-		assert_eq!(Society::members(), vec![10]);
+		assert_eq!(members(), vec![10]);
 
 		// 10 cannot vouch again
 		assert_noop!(
@@ -497,7 +518,7 @@ fn unvouch_works() {
 fn unbid_vouch_works() {
 	EnvBuilder::new().execute(|| {
 		// 10 is the only member
-		assert_eq!(Society::members(), vec![10]);
+		assert_eq!(members(), vec![10]);
 		// 10 vouches for 20
 		assert_ok!(Society::vouch(Origin::signed(10), 20, 100, 0));
 		// 20 has a bid
@@ -516,9 +537,9 @@ fn unbid_vouch_works() {
 fn founder_and_head_cannot_be_removed() {
 	EnvBuilder::new().execute(|| {
 		// 10 is the only member, founder, and head
-		assert_eq!(Society::members(), vec![10]);
-		assert_eq!(Society::founder(), Some(10));
-		assert_eq!(Society::head(), Some(10));
+		assert_eq!(members(), vec![10]);
+		assert_eq!(Founder::<Test>::get(), Some(10));
+		assert_eq!(Head::<Test>::get(), Some(10));
 		// 10 can still accumulate strikes
 		assert_ok!(Society::bid(Origin::signed(20), 0));
 		run_to_block(8);
@@ -537,10 +558,10 @@ fn founder_and_head_cannot_be_removed() {
 		assert_ok!(Society::vote(Origin::signed(10), 50, true));
 		assert_ok!(Society::defender_vote(Origin::signed(10), true)); // Keep defender around
 		run_to_block(32);
-		assert_eq!(Society::members(), vec![10, 50]);
-		assert_eq!(Society::head(), Some(50));
+		assert_eq!(members(), vec![10, 50]);
+		assert_eq!(Head::<Test>::get(), Some(50));
 		// Founder is unchanged
-		assert_eq!(Society::founder(), Some(10));
+		assert_eq!(Founder::<Test>::get(), Some(10));
 
 		// 50 can still accumulate strikes
 		assert_ok!(Society::bid(Origin::signed(60), 0));
@@ -557,9 +578,9 @@ fn founder_and_head_cannot_be_removed() {
 		assert_ok!(Society::vote(Origin::signed(50), 80, true));
 		assert_ok!(Society::defender_vote(Origin::signed(10), true)); // Keep defender around
 		run_to_block(56);
-		assert_eq!(Society::members(), vec![10, 50, 80]);
-		assert_eq!(Society::head(), Some(80));
-		assert_eq!(Society::founder(), Some(10));
+		assert_eq!(members(), vec![10, 50, 80]);
+		assert_eq!(Head::<Test>::get(), Some(80));
+		assert_eq!(Founder::<Test>::get(), Some(10));
 
 		// 50 can now be suspended for strikes
 		assert_ok!(Society::bid(Origin::signed(90), 0));
@@ -569,7 +590,7 @@ fn founder_and_head_cannot_be_removed() {
 		run_to_block(64);
 		assert_eq!(Strikes::<Test>::get(50), 0);
 		assert_eq!(<SuspendedMembers<Test>>::get(50), true);
-		assert_eq!(Society::members(), vec![10, 80]);
+		assert_eq!(members(), vec![10, 80]);
 	});
 }
 
@@ -586,7 +607,7 @@ fn challenges_work() {
 		assert_eq!(<DefenderVotes<Test>>::get(30), None);
 		assert_eq!(<DefenderVotes<Test>>::get(40), None);
 		// Check starting point
-		assert_eq!(Society::members(), vec![10, 20, 30, 40]);
+		assert_eq!(members(), vec![10, 20, 30, 40]);
 		assert_eq!(Society::defender(), None);
 		// 20 will be challenged during the challenge rotation
 		run_to_block(8);
@@ -595,7 +616,7 @@ fn challenges_work() {
 		assert_ok!(Society::defender_vote(Origin::signed(30), true));
 		// If no one else votes, nothing happens
 		run_to_block(16);
-		assert_eq!(Society::members(), vec![10, 20, 30, 40]);
+		assert_eq!(members(), vec![10, 20, 30, 40]);
 		// New challenge period
 		assert_eq!(Society::defender(), Some(30));
 		// Non-member cannot challenge
@@ -607,7 +628,7 @@ fn challenges_work() {
 		assert_ok!(Society::defender_vote(Origin::signed(40), false));
 		run_to_block(24);
 		// 20 survives
-		assert_eq!(Society::members(), vec![10, 20, 30, 40]);
+		assert_eq!(members(), vec![10, 20, 30, 40]);
 		// Votes are reset
 		assert_eq!(<DefenderVotes<Test>>::get(10), None);
 		assert_eq!(<DefenderVotes<Test>>::get(20), None);
@@ -622,7 +643,7 @@ fn challenges_work() {
 		assert_ok!(Society::defender_vote(Origin::signed(40), false));
 		run_to_block(32);
 		// 20 is suspended
-		assert_eq!(Society::members(), vec![10, 20, 40]);
+		assert_eq!(members(), vec![10, 20, 40]);
 		assert_eq!(Society::suspended_member(30), true);
 		// New defender is chosen
 		assert_eq!(Society::defender(), Some(20));
@@ -647,7 +668,7 @@ fn bad_vote_slash_works() {
 		Society::bump_payout(&30, 5, 100);
 		Society::bump_payout(&40, 5, 100);
 		// Check starting point
-		assert_eq!(Society::members(), vec![10, 20, 30, 40]);
+		assert_eq!(members(), vec![10, 20, 30, 40]);
 		assert_eq!(<Payouts<Test>>::get(10), vec![(5, 100)]);
 		assert_eq!(<Payouts<Test>>::get(20), vec![(5, 100)]);
 		assert_eq!(<Payouts<Test>>::get(30), vec![(5, 100)]);
@@ -727,22 +748,22 @@ fn vouching_handles_removed_member_with_candidate() {
 		assert_eq!(<Vouching<Test>>::get(20), Some(VouchingStatus::Vouching));
 		// Make that bid a candidate
 		run_to_block(4);
-		assert_eq!(Society::candidates(), vec![create_bid(1000, 30, BidKind::Vouch(20, 100))]);
+		assert_eq!(candidates(), vec![create_bid(1000, 30, BidKind::Vouch(20, 100))]);
 		// Suspend that member
 		Society::suspend_member(&20);
 		assert_eq!(<SuspendedMembers<Test>>::get(20), true);
 		// Nothing changes yet
-		assert_eq!(Society::candidates(), vec![create_bid(1000, 30, BidKind::Vouch(20, 100))]);
+		assert_eq!(candidates(), vec![create_bid(1000, 30, BidKind::Vouch(20, 100))]);
 		assert_eq!(<Vouching<Test>>::get(20), Some(VouchingStatus::Vouching));
 		// Remove member
 		assert_ok!(Society::judge_suspended_member(Origin::signed(2), 20, false));
 		// Vouching status is removed, but candidate is still in the queue
 		assert_eq!(<Vouching<Test>>::get(20), None);
-		assert_eq!(Society::candidates(), vec![create_bid(1000, 30, BidKind::Vouch(20, 100))]);
+		assert_eq!(candidates(), vec![create_bid(1000, 30, BidKind::Vouch(20, 100))]);
 		// Candidate wins
 		assert_ok!(Society::vote(Origin::signed(10), 30, true));
 		run_to_block(8);
-		assert_eq!(Society::members(), vec![10, 30]);
+		assert_eq!(members(), vec![10, 30]);
 		// Payout does not go to removed member
 		assert_eq!(<Payouts<Test>>::get(20), vec![]);
 		assert_eq!(<Payouts<Test>>::get(30), vec![(9, 1000)]);
@@ -769,7 +790,7 @@ fn votes_are_working() {
 		assert_eq!(<Votes<Test>>::get(50, 10), None);
 		run_to_block(8);
 		// Candidates become members after a period rotation
-		assert_eq!(Society::members(), vec![10, 30, 40]);
+		assert_eq!(members(), vec![10, 30, 40]);
 		// Votes are cleaned up
 		assert_eq!(<Votes<Test>>::get(30, 10), None);
 		assert_eq!(<Votes<Test>>::get(40, 10), None);
@@ -796,17 +817,17 @@ fn max_limits_work() {
 		// Rotate period
 		run_to_block(4);
 		// Max of 10 candidates
-		assert_eq!(Society::candidates().len(), 10);
+		assert_eq!(candidates().len(), 10);
 		// Fill up membership, max 100, we will do just 95
 		for i in 2000..2095 {
 			assert_ok!(Society::add_member(&(i as u128)));
 		}
 		// Remember there was 1 original member, so 96 total
-		assert_eq!(Society::members().len(), 96);
+		assert_eq!(members().len(), 96);
 		// Rotate period
 		run_to_block(8);
 		// Only of 4 candidates possible now
-		assert_eq!(Society::candidates().len(), 4);
+		assert_eq!(candidates().len(), 4);
 		// Fill up members with suspended candidates from the first rotation
 		for i in 100..104 {
 			assert_ok!(Society::judge_suspended_candidate(
@@ -815,12 +836,12 @@ fn max_limits_work() {
 				Judgement::Approve
 			));
 		}
-		assert_eq!(Society::members().len(), 100);
+		assert_eq!(members().len(), 100);
 		// Can't add any more members
 		assert_noop!(Society::add_member(&98), Error::<Test, _>::MaxMembers);
 		// However, a fringe scenario allows for in-progress candidates to increase the membership
 		// pool, but it has no real after-effects.
-		for i in Society::members().iter() {
+		for i in members().iter() {
 			assert_ok!(Society::vote(Origin::signed(*i), 110, true));
 			assert_ok!(Society::vote(Origin::signed(*i), 111, true));
 			assert_ok!(Society::vote(Origin::signed(*i), 112, true));
@@ -828,15 +849,15 @@ fn max_limits_work() {
 		// Rotate period
 		run_to_block(12);
 		// Members length is over 100, no problem...
-		assert_eq!(Society::members().len(), 103);
+		assert_eq!(members().len(), 103);
 		// No candidates because full
-		assert_eq!(Society::candidates().len(), 0);
+		assert_eq!(candidates().len(), 0);
 		// Increase member limit
 		assert_ok!(Society::set_max_members(Origin::root(), 200));
 		// Rotate period
 		run_to_block(16);
 		// Candidates are back!
-		assert_eq!(Society::candidates().len(), 10);
+		assert_eq!(candidates().len(), 10);
 	});
 }
 
@@ -856,11 +877,11 @@ fn zero_bid_works() {
 		// Rotate period
 		run_to_block(4);
 		// Pot is 1000 after "PeriodSpend"
-		assert_eq!(Society::pot(), 1000);
+		assert_eq!(Pot::<Test>::get(), 1000);
 		assert_eq!(Balances::free_balance(Society::account_id()), 10_000);
 		// Choose smallest bidding users whose total is less than pot, with only one zero bid.
 		assert_eq!(
-			Society::candidates(),
+			candidates(),
 			vec![
 				create_bid(0, 30, BidKind::Deposit(25)),
 				create_bid(300, 50, BidKind::Deposit(25)),
@@ -877,9 +898,9 @@ fn zero_bid_works() {
 		assert_ok!(Society::vote(Origin::signed(10), 60, true));
 		run_to_block(8);
 		// Candidates become members after a period rotation
-		assert_eq!(Society::members(), vec![10, 30, 50, 60]);
+		assert_eq!(members(), vec![10, 30, 50, 60]);
 		// The zero bid is selected as head
-		assert_eq!(Society::head(), Some(30));
+		assert_eq!(Head::<Test>::get(), Some(30));
 	});
 }
 
@@ -907,3 +928,4 @@ fn bids_ordered_correctly() {
 		assert_eq!(<Bids<Test>>::get(), final_list);
 	});
 }
+*/
\ No newline at end of file
diff --git a/primitives/core/src/traits.rs b/primitives/core/src/traits.rs
index a799e3285fe5d..fc4bd908874d3 100644
--- a/primitives/core/src/traits.rs
+++ b/primitives/core/src/traits.rs
@@ -285,3 +285,42 @@ pub trait FromEntropy: Sized {
 	/// `input` has an error.
 	fn from_entropy(input: &mut impl codec::Input) -> Result<Self, codec::Error>;
 }
+
+impl FromEntropy for bool {
+	fn from_entropy(input: &mut impl codec::Input) -> Result<Self, codec::Error> {
+		Ok(input.read_byte()? % 2 == 1)
+	}
+}
+
+macro_rules! impl_from_entropy {
+	($type:ty , $( $others:tt )*) => {
+		impl_from_entropy!($type);
+		impl_from_entropy!($( $others )*);
+	};
+	($type:ty) => {
+		impl FromEntropy for $type {
+			fn from_entropy(input: &mut impl codec::Input) -> Result<Self, codec::Error> {
+				<Self as codec::Decode>::decode(input)
+			}
+		}
+	}
+}
+
+macro_rules! impl_from_entropy_base {
+	($type:ty , $( $others:tt )*) => {
+		impl_from_entropy_base!($type);
+		impl_from_entropy_base!($( $others )*);
+	};
+	($type:ty) => {
+		impl_from_entropy!($type,
+			[$type; 1], [$type; 2], [$type; 3], [$type; 4], [$type; 5], [$type; 6], [$type; 7], [$type; 8],
+			[$type; 9], [$type; 10], [$type; 11], [$type; 12], [$type; 13], [$type; 14], [$type; 15], [$type; 16],
+			[$type; 17], [$type; 18], [$type; 19], [$type; 20], [$type; 21], [$type; 22], [$type; 23], [$type; 24],
+			[$type; 25], [$type; 26], [$type; 27], [$type; 28], [$type; 29], [$type; 30], [$type; 31], [$type; 32],
+			[$type; 36], [$type; 40], [$type; 44], [$type; 48], [$type; 56], [$type; 64], [$type; 72], [$type; 80],
+			[$type; 96], [$type; 112], [$type; 128], [$type; 160], [$type; 192], [$type; 224], [$type; 256]
+		);
+	}
+}
+
+impl_from_entropy_base!(u8, u16, u32, u64, u128, i8, i16, i32, i64, i128);

From f7ce7e39e1e6980f32179c45d7d04e94cb44bfa5 Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@parity.io>
Date: Wed, 4 May 2022 12:15:16 +0100
Subject: [PATCH 06/43] Fixes

---
 frame/society/src/lib.rs   |  32 ++++++------
 frame/society/src/mock.rs  |   5 +-
 frame/society/src/tests.rs | 100 ++++++++++++++++++++++++-------------
 3 files changed, 85 insertions(+), 52 deletions(-)

diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index e11d7982bec1d..b0d1f6d249f05 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -1462,7 +1462,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		round: RoundIndex,
 		member_count: u32,
 		pot: BalanceOf<T, I>,
-	) -> usize {
+	) -> u32 {
 		// Get the number of left-most bidders whose bids add up to less than `pot`.
 		let mut bids = Bids::<T, I>::get();
 		let params = match Parameters::<T, I>::get() {
@@ -1498,7 +1498,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 
 		// No need to reset Bids if we're not taking anything.
 		Bids::<T, I>::put(&bids);
-		bids.len()
+		selections
 	}
 
 	/// Puts a bid into storage ordered by smallest to largest value.
@@ -1613,6 +1613,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 			// Way too many strikes: suspend.
 			Self::suspend_member(who);
 		}
+		Members::<T, I>::insert(who, &record);
 		Ok(())
 	}
 
@@ -1774,20 +1775,19 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	/// If it the caller's duty to ensure that `who` is already a member. This does nothing if `who`
 	/// is not a member or if `value` is zero.
 	fn bump_payout(who: &T::AccountId, when: T::BlockNumber, value: BalanceOf<T, I>) {
-		if !value.is_zero() {
-			if let Some(MemberRecord { rank: 0, .. }) = Members::<T, I>::get(who) {
-				Payouts::<T, I>::mutate_extant(who, |record| {
-					// Members of rank 1 never get payouts.
-					match record.payouts.binary_search_by_key(&when, |x| x.0) {
-						Ok(index) => record.payouts[index].1.saturating_accrue(value),
-						Err(index) => {
-							// If they have too many pending payouts, then we take discard the payment.
-							let _ = record.payouts.try_insert(index, (when, value));
-						},
-					}
-				});
-				Self::reserve_payout(value);
-			}
+		if value.is_zero() { return }
+		if let Some(MemberRecord { rank: 0, .. }) = Members::<T, I>::get(who) {
+			Payouts::<T, I>::mutate(who, |record| {
+				// Members of rank 1 never get payouts.
+				match record.payouts.binary_search_by_key(&when, |x| x.0) {
+					Ok(index) => record.payouts[index].1.saturating_accrue(value),
+					Err(index) => {
+						// If they have too many pending payouts, then we take discard the payment.
+						let _ = record.payouts.try_insert(index, (when, value));
+					},
+				}
+			});
+			Self::reserve_payout(value);
 		}
 	}
 
diff --git a/frame/society/src/mock.rs b/frame/society/src/mock.rs
index dc41295fe7645..d3b8e5168346d 100644
--- a/frame/society/src/mock.rs
+++ b/frame/society/src/mock.rs
@@ -153,7 +153,10 @@ impl EnvBuilder {
 		.unwrap();
 		let mut ext: sp_io::TestExternalities = t.into();
 		ext.execute_with(|| {
-			assert!(Society::found_society(Origin::signed(1), 10, 100, 10, 2, 25, b"be cool".to_vec()).is_ok());
+			if self.founded {
+				let r = b"be cool".to_vec();
+				assert!(Society::found_society(Origin::signed(1), 10, 100, 10, 2, 25, r).is_ok());
+			}
 			f()
 		})
 	}
diff --git a/frame/society/src/tests.rs b/frame/society/src/tests.rs
index 55e36cc542c90..c377bbdafb654 100644
--- a/frame/society/src/tests.rs
+++ b/frame/society/src/tests.rs
@@ -197,20 +197,18 @@ fn unbidding_works() {
 		// Balances are reserved
 		assert_eq!(Balances::free_balance(30), 25);
 		assert_eq!(Balances::reserved_balance(30), 25);
-		// Must know right position to unbid + cannot unbid someone else
-		assert_noop!(Society::unbid(Origin::signed(30), 1), Error::<Test, _>::BadPosition);
 		// Can unbid themselves with the right position
-		assert_ok!(Society::unbid(Origin::signed(30), 0));
+		assert_ok!(Society::unbid(Origin::signed(30)));
+		assert_noop!(Society::unbid(Origin::signed(30)), Error::<Test, _>::NotBidder);
 		// Balance is returned
 		assert_eq!(Balances::free_balance(30), 50);
 		assert_eq!(Balances::reserved_balance(30), 0);
 		// 20 wins candidacy
 		run_to_block(4);
-		assert_eq!(candidates(), vec![create_bid(1000, 20, BidKind::Deposit(25))]);
+		assert_eq!(candidates(), vec![(20, candidacy(1, 1000, BidKind::Deposit(25), 0, 0))]);
 	});
 }
 
-/*
 #[test]
 fn payout_works() {
 	EnvBuilder::new().execute(|| {
@@ -219,10 +217,11 @@ fn payout_works() {
 		assert_ok!(Society::bid(Origin::signed(20), 1000));
 		run_to_block(4);
 		assert_ok!(Society::vote(Origin::signed(10), 20, true));
-		run_to_block(8);
+		run_to_block(7);
+		assert_ok!(Society::claim_membership(Origin::signed(20)));
 		// payout not ready
 		assert_noop!(Society::payout(Origin::signed(20)), Error::<Test, _>::NoPayout);
-		run_to_block(9);
+		run_to_block(8);
 		// payout should be here
 		assert_ok!(Society::payout(Origin::signed(20)));
 		assert_eq!(Balances::free_balance(20), 1050);
@@ -230,18 +229,49 @@ fn payout_works() {
 }
 
 #[test]
-fn basic_new_member_skeptic_works() {
+fn non_voting_skeptic_is_punished() {
 	EnvBuilder::new().execute(|| {
-		assert_eq!(Strikes::<Test>::get(10), 0);
+		assert_eq!(Members::<Test>::get(10).unwrap().strikes, 0);
 		assert_ok!(Society::bid(Origin::signed(20), 0));
 		run_to_block(4);
-		assert_eq!(candidates(), vec![create_bid(0, 20, BidKind::Deposit(25))]);
+		assert_eq!(candidates(), vec![(20, candidacy(1, 0, BidKind::Deposit(25), 0, 0))]);
+		run_to_block(7);
+		assert_noop!(Society::claim_membership(Origin::signed(20)), Error::<Test>::NotApproved);
+		assert_ok!(Society::resign_candidate(Origin::signed(20)));
 		run_to_block(8);
 		assert_eq!(members(), vec![10]);
-		assert_eq!(Strikes::<Test>::get(10), 1);
+		assert_eq!(Members::<Test>::get(10).unwrap().strikes, 1);
 	});
 }
 
+#[test]
+fn rejecting_skeptic_on_approved_is_punished() {
+	EnvBuilder::new().execute(|| {
+		assert_eq!(Members::<Test>::get(10).unwrap().strikes, 0);
+		assert_ok!(Society::bid(Origin::signed(20), 0));
+		assert_ok!(Society::bid(Origin::signed(30), 1));
+		run_to_block(4);
+		assert_ok!(Society::bid(Origin::signed(40), 0));
+
+		assert_ok!(Society::vote(Origin::signed(10), 20, true));
+		assert_ok!(Society::vote(Origin::signed(10), 30, true));
+		run_to_block(7);
+		assert_ok!(Society::claim_membership(Origin::signed(20)));
+		assert_ok!(Society::claim_membership(Origin::signed(30)));
+		run_to_block(8);
+		let skeptic = Skeptic::<Test>::get().unwrap();
+		for &i in &[10, 20, 30][..] {
+			assert_ok!(Society::vote(Origin::signed(i), 40, i != skeptic));
+		}
+		run_to_block(11);
+		assert_ok!(Society::claim_membership(Origin::signed(40)));
+		run_to_block(12);
+		assert_eq!(members(), vec![10, 20, 30, 40]);
+		assert_eq!(Members::<Test>::get(skeptic).unwrap().strikes, 1);
+	});
+}
+
+/*
 #[test]
 fn basic_new_member_reject_works() {
 	EnvBuilder::new().execute(|| {
@@ -253,7 +283,7 @@ fn basic_new_member_reject_works() {
 		assert_eq!(Balances::reserved_balance(20), 25);
 		// Rotation Period
 		run_to_block(4);
-		assert_eq!(candidates(), vec![create_bid(0, 20, BidKind::Deposit(25))]);
+		assert_eq!(candidates(), vec![(20, candidacy(1, 0, BidKind::Deposit(25), 0, 0))]);
 		// We say no
 		assert_ok!(Society::vote(Origin::signed(10), 20, false));
 		run_to_block(8);
@@ -363,7 +393,7 @@ fn suspended_candidate_rejected_works() {
 		assert_eq!(Balances::reserved_balance(20), 25);
 		// Rotation Period
 		run_to_block(4);
-		assert_eq!(candidates(), vec![create_bid(0, 20, BidKind::Deposit(25))]);
+		assert_eq!(candidates(), vec![(20, candidacy(1, 0, BidKind::Deposit(25), 0, 0))]);
 		// We say no
 		assert_ok!(Society::vote(Origin::signed(10), 20, false));
 		run_to_block(8);
@@ -384,7 +414,7 @@ fn suspended_candidate_rejected_works() {
 		// They are placed back in bid pool, repeat suspension process
 		// Rotation Period
 		run_to_block(12);
-		assert_eq!(candidates(), vec![create_bid(0, 20, BidKind::Deposit(25))]);
+		assert_eq!(candidates(), vec![(20, candidacy(1, 0, BidKind::Deposit(25), 0, 0))]);
 		// We say no
 		assert_ok!(Society::vote(Origin::signed(10), 20, false));
 		run_to_block(16);
@@ -423,10 +453,10 @@ fn vouch_works() {
 			Error::<Test, _>::AlreadyVouching
 		);
 		// Vouching creates the right kind of bid
-		assert_eq!(<Bids<Test>>::get(), vec![create_bid(1000, 20, BidKind::Vouch(10, 100))]);
+		assert_eq!(<Bids<Test>>::get(), vec![(20, candidacy(1, 1000, BidKind::Vouch(10,, 0, 0) 100))]);
 		// Vouched user can become candidate
 		run_to_block(4);
-		assert_eq!(candidates(), vec![create_bid(1000, 20, BidKind::Vouch(10, 100))]);
+		assert_eq!(candidates(), vec![(20, candidacy(1, 1000, BidKind::Vouch(10,, 0, 0) 100))]);
 		// Vote yes
 		assert_ok!(Society::vote(Origin::signed(10), 20, true));
 		// Vouched user can win
@@ -449,10 +479,10 @@ fn voucher_cannot_win_more_than_bid() {
 		// 10 vouches, but asks for more than the bid
 		assert_ok!(Society::vouch(Origin::signed(10), 20, 100, 1000));
 		// Vouching creates the right kind of bid
-		assert_eq!(<Bids<Test>>::get(), vec![create_bid(100, 20, BidKind::Vouch(10, 1000))]);
+		assert_eq!(<Bids<Test>>::get(), vec![(20, candidacy(1, 100, BidKind::Vouch(10,, 0, 0) 1000))]);
 		// Vouched user can become candidate
 		run_to_block(4);
-		assert_eq!(candidates(), vec![create_bid(100, 20, BidKind::Vouch(10, 1000))]);
+		assert_eq!(candidates(), vec![(20, candidacy(1, 100, BidKind::Vouch(10,, 0, 0) 1000))]);
 		// Vote yes
 		assert_ok!(Society::vote(Origin::signed(10), 20, true));
 		// Vouched user can win
@@ -473,7 +503,7 @@ fn unvouch_works() {
 		// 10 vouches for 20
 		assert_ok!(Society::vouch(Origin::signed(10), 20, 100, 0));
 		// 20 has a bid
-		assert_eq!(<Bids<Test>>::get(), vec![create_bid(100, 20, BidKind::Vouch(10, 0))]);
+		assert_eq!(<Bids<Test>>::get(), vec![(20, candidacy(1, 100, BidKind::Vouch(10,, 0, 0) 0))]);
 		// 10 is vouched
 		assert_eq!(<Vouching<Test>>::get(10), Some(VouchingStatus::Vouching));
 		// To unvouch, you must know the right bid position
@@ -488,7 +518,7 @@ fn unvouch_works() {
 		// Cannot unvouch after they become candidate
 		assert_ok!(Society::vouch(Origin::signed(10), 20, 100, 0));
 		run_to_block(4);
-		assert_eq!(candidates(), vec![create_bid(100, 20, BidKind::Vouch(10, 0))]);
+		assert_eq!(candidates(), vec![(20, candidacy(1, 100, BidKind::Vouch(10,, 0, 0) 0))]);
 		assert_noop!(Society::unvouch(Origin::signed(10), 0), Error::<Test, _>::BadPosition);
 		// 10 is still vouching until candidate is approved or rejected
 		assert_eq!(<Vouching<Test>>::get(10), Some(VouchingStatus::Vouching));
@@ -522,11 +552,11 @@ fn unbid_vouch_works() {
 		// 10 vouches for 20
 		assert_ok!(Society::vouch(Origin::signed(10), 20, 100, 0));
 		// 20 has a bid
-		assert_eq!(<Bids<Test>>::get(), vec![create_bid(100, 20, BidKind::Vouch(10, 0))]);
+		assert_eq!(<Bids<Test>>::get(), vec![(20, candidacy(1, 100, BidKind::Vouch(10,, 0, 0) 0))]);
 		// 10 is vouched
 		assert_eq!(<Vouching<Test>>::get(10), Some(VouchingStatus::Vouching));
 		// 20 doesn't want to be a member and can unbid themselves.
-		assert_ok!(Society::unbid(Origin::signed(20), 0));
+		assert_ok!(Society::unbid(Origin::signed(20)));
 		// Everything is cleaned up
 		assert_eq!(<Vouching<Test>>::get(10), None);
 		assert_eq!(<Bids<Test>>::get(), vec![]);
@@ -720,13 +750,13 @@ fn vouching_handles_removed_member_with_bid() {
 		// Have that member vouch for a user
 		assert_ok!(Society::vouch(Origin::signed(20), 30, 1000, 100));
 		// That user is now a bid and the member is vouching
-		assert_eq!(<Bids<Test>>::get(), vec![create_bid(1000, 30, BidKind::Vouch(20, 100))]);
+		assert_eq!(<Bids<Test>>::get(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20,, 0, 0) 100))]);
 		assert_eq!(<Vouching<Test>>::get(20), Some(VouchingStatus::Vouching));
 		// Suspend that member
 		Society::suspend_member(&20);
 		assert_eq!(<SuspendedMembers<Test>>::get(20), true);
 		// Nothing changes yet
-		assert_eq!(<Bids<Test>>::get(), vec![create_bid(1000, 30, BidKind::Vouch(20, 100))]);
+		assert_eq!(<Bids<Test>>::get(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20,, 0, 0) 100))]);
 		assert_eq!(<Vouching<Test>>::get(20), Some(VouchingStatus::Vouching));
 		// Remove member
 		assert_ok!(Society::judge_suspended_member(Origin::signed(2), 20, false));
@@ -744,22 +774,22 @@ fn vouching_handles_removed_member_with_candidate() {
 		// Have that member vouch for a user
 		assert_ok!(Society::vouch(Origin::signed(20), 30, 1000, 100));
 		// That user is now a bid and the member is vouching
-		assert_eq!(<Bids<Test>>::get(), vec![create_bid(1000, 30, BidKind::Vouch(20, 100))]);
+		assert_eq!(<Bids<Test>>::get(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20,, 0, 0) 100))]);
 		assert_eq!(<Vouching<Test>>::get(20), Some(VouchingStatus::Vouching));
 		// Make that bid a candidate
 		run_to_block(4);
-		assert_eq!(candidates(), vec![create_bid(1000, 30, BidKind::Vouch(20, 100))]);
+		assert_eq!(candidates(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20,, 0, 0) 100))]);
 		// Suspend that member
 		Society::suspend_member(&20);
 		assert_eq!(<SuspendedMembers<Test>>::get(20), true);
 		// Nothing changes yet
-		assert_eq!(candidates(), vec![create_bid(1000, 30, BidKind::Vouch(20, 100))]);
+		assert_eq!(candidates(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20,, 0, 0) 100))]);
 		assert_eq!(<Vouching<Test>>::get(20), Some(VouchingStatus::Vouching));
 		// Remove member
 		assert_ok!(Society::judge_suspended_member(Origin::signed(2), 20, false));
 		// Vouching status is removed, but candidate is still in the queue
 		assert_eq!(<Vouching<Test>>::get(20), None);
-		assert_eq!(candidates(), vec![create_bid(1000, 30, BidKind::Vouch(20, 100))]);
+		assert_eq!(candidates(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20,, 0, 0) 100))]);
 		// Candidate wins
 		assert_ok!(Society::vote(Origin::signed(10), 30, true));
 		run_to_block(8);
@@ -811,9 +841,9 @@ fn max_limits_work() {
 		// Length is 1000
 		assert_eq!(bids.len(), 1000);
 		// First bid is smallest number (100)
-		assert_eq!(bids[0], create_bid(100, 100, BidKind::Deposit(25)));
+		assert_eq!(bids[0], (100, candidacy(1, 100, BidKind::Deposit(25), 0, 0)));
 		// Last bid is smallest number + 99 (1099)
-		assert_eq!(bids[999], create_bid(1099, 1099, BidKind::Deposit(25)));
+		assert_eq!(bids[999], (1099, candidacy(1, 1099, BidKind::Deposit(25), 0, 0)));
 		// Rotate period
 		run_to_block(4);
 		// Max of 10 candidates
@@ -883,14 +913,14 @@ fn zero_bid_works() {
 		assert_eq!(
 			candidates(),
 			vec![
-				create_bid(0, 30, BidKind::Deposit(25)),
-				create_bid(300, 50, BidKind::Deposit(25)),
-				create_bid(400, 60, BidKind::Deposit(25)),
+				(30, candidacy(1, 0, BidKind::Deposit(25), 0, 0)),
+				(50, candidacy(1, 300, BidKind::Deposit(25), 0, 0)),
+				(60, candidacy(1, 400, BidKind::Deposit(25), 0, 0)),
 			]
 		);
 		assert_eq!(
 			<Bids<Test>>::get(),
-			vec![create_bid(0, 20, BidKind::Deposit(25)), create_bid(0, 40, BidKind::Deposit(25)),]
+			vec![(20, candidacy(1, 0, BidKind::Deposit(25), 0, 0)), (40, candidacy(1, 0, BidKind::Deposit(25), 0, 0)),]
 		);
 		// A member votes for these candidates to join the society
 		assert_ok!(Society::vote(Origin::signed(10), 30, true));
@@ -921,7 +951,7 @@ fn bids_ordered_correctly() {
 
 		for j in 0..5 {
 			for i in 0..5 {
-				final_list.push(create_bid(j, 100 + (i * 5 + j) as u128, BidKind::Deposit(25)));
+				final_list.push((100 +candidacy(j1, ,  (i * 5 + j), 0, 0) as u128, BidKind::Deposit(25)));
 			}
 		}
 

From 841c732f922576ef4f1cc98442a97fb4ec92c84b Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@parity.io>
Date: Wed, 4 May 2022 15:38:36 +0100
Subject: [PATCH 07/43] Improvements to the voting process

---
 frame/society/src/lib.rs   | 131 ++++++++---
 frame/society/src/mock.rs  |   2 +-
 frame/society/src/tests.rs | 461 +++++++++++++++++++++----------------
 3 files changed, 368 insertions(+), 226 deletions(-)

diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index b0d1f6d249f05..6b99e31c8bb1b 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -257,7 +257,7 @@ use frame_support::{
 	pallet_prelude::*,
 	traits::{
 		Currency, EnsureOrigin, ExistenceRequirement::AllowDeath,
-		Imbalance, OnUnbalanced, Randomness, ReservableCurrency,
+		Imbalance, OnUnbalanced, Randomness, ReservableCurrency, BalanceStatus,
 	},
 	PalletId,
 };
@@ -375,6 +375,14 @@ impl Tally {
 	fn more_rejections(&self) -> bool {
 		self.rejections > self.approvals
 	}
+
+	fn clear_approval(&self) -> bool {
+		self.approvals >= (2 * self.rejections).max(1)
+	}
+
+	fn clear_rejection(&self) -> bool {
+		self.rejections >= (2 * self.approvals).max(1)
+	}
 }
 
 /// A bid for entry into society.
@@ -388,6 +396,8 @@ pub struct Candidacy<AccountId, Balance> {
 	bid: Balance,
 	/// The tally of votes so far.
 	tally: Tally,
+	/// True if the skeptic was already punished for note voting.
+	skeptic_struck: bool,
 }
 
 /// A vote by a member on a candidate application.
@@ -572,12 +582,16 @@ pub mod pallet {
 		NotFounder,
 		/// The caller is not the head.
 		NotHead,
-		/// The membership cannot be claimed as the member does not (yet) have enough votes.
+		/// The membership cannot be claimed as the candidate was not clearly approved.
 		NotApproved,
-		/// The candidacy cannot be claimed/dropped as the voting is still in progress.
-		InProgress,
-		/// The candidacy cannot be dropped as the candidate is approved.
+		/// The candidate cannot be kicked as the candidate was not clearly rejected.
+		NotRejected,
+		/// The candidacy cannot be dropped as the candidate was clearly approved.
 		Approved,
+		/// The candidacy cannot be bestowed as the candidate was clearly rejected.
+		Rejected,
+		/// The candidacy cannot be concluded as the voting is still in progress.
+		InProgress,
 		/// The candidacy cannot be pruned until a full additional intake period has passed.
 		TooEarly,
 		/// The skeptic already voted.
@@ -592,6 +606,8 @@ pub mod pallet {
 		NotGroup,
 		/// The member is already elevated to this rank.
 		AlreadyElevated,
+		/// The skeptic has already been punished for this offence.
+		AlreadyPunished,
 	}
 
 	#[pallet::event]
@@ -1044,6 +1060,7 @@ pub mod pallet {
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
 		pub fn payout(origin: OriginFor<T>) -> DispatchResult {
 			let who = ensure_signed(origin)?;
+			ensure!(Members::<T, I>::get(&who).ok_or(Error::<T, I>::NotMember)?.rank == 0, Error::<T, I>::NoPayout);
 			let mut record = Payouts::<T, I>::get(&who);
 
 			if let Some((when, amount)) = record.payouts.first() {
@@ -1218,65 +1235,90 @@ pub mod pallet {
 			Ok(())
 		}
 
+		/// Punish the skeptic with a strike if they did not vote on a candidate. Callable by the
+		/// candidate.
+		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		pub fn punish_skeptic(origin: OriginFor<T>) -> DispatchResult {
+			let candidate = ensure_signed(origin)?;
+			let mut candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			ensure!(!candidacy.skeptic_struck, Error::<T, I>::AlreadyPunished);
+			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
+			Self::check_skeptic(&candidate, &mut candidacy);
+			Candidates::<T, I>::insert(&candidate, candidacy);
+			Ok(())
+		}
+
 		/// Transform an approved candidate into a member. Callable only by the
 		/// the candidate, and only after the period for voting has ended.
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
 		pub fn claim_membership(origin: OriginFor<T>) -> DispatchResult {
 			let candidate = ensure_signed(origin)?;
 			let candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
-			ensure!(candidacy.tally.more_approvals(), Error::<T, I>::NotApproved);
+			ensure!(candidacy.tally.clear_approval(), Error::<T, I>::NotApproved);
 			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
 			Self::induct_member(candidate, candidacy, 0)
 		}
 
 		/// Transform an approved candidate into a member. Callable only by the Signed origin of the
-		/// Founder and only after the period for voting has ended.
+		/// Founder, only after the period for voting has ended and only when the candidate is not
+		/// clearly rejected.
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
-		pub fn force_membership(origin: OriginFor<T>, candidate: T::AccountId) -> DispatchResult {
+		pub fn bestow_membership(origin: OriginFor<T>, candidate: T::AccountId) -> DispatchResult {
 			let founder = ensure_signed(origin)?;
 			ensure!(Founder::<T, I>::get() == Some(founder.clone()), Error::<T, I>::NotFounder);
-
 			let candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			ensure!(!candidacy.tally.clear_rejection(), Error::<T, I>::Rejected);
 			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
 			Self::induct_member(candidate, candidacy, 0)
 		}
 
 		/// Remove the candidate's application from the society. Callable only by the Signed origin
-		/// of the Founder, and only after the period for voting has ended.
+		/// of the Founder, only after the period for voting has ended, and only when they do not
+		/// have a clear approval.
+		///
+		/// Any bid deposit is lost and voucher is banned.
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
 		pub fn kick_candidate(origin: OriginFor<T>, candidate: T::AccountId) -> DispatchResult {
 			let founder = ensure_signed(origin)?;
 			ensure!(Founder::<T, I>::get() == Some(founder.clone()), Error::<T, I>::NotFounder);
-			let candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			let mut candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
 			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
-			Self::check_skeptic(&candidate, &candidacy);
+			ensure!(!candidacy.tally.clear_approval(), Error::<T, I>::Approved);
+			Self::check_skeptic(&candidate, &mut candidacy);
+			Self::reject_candidate(&candidate, &candidacy.kind);
 			Votes::<T, I>::remove_prefix(&candidate, None);
 			Candidates::<T, I>::remove(&candidate);
 			Ok(())
 		}
 
-		/// Remove the candidate's failed application from the society. Callable only by the
-		/// the candidate, and only after the period for voting has ended.
+		/// Remove the candidate's application from the society. Callable only by the candidate.
+		///
+		/// Any bid deposit is lost and voucher is banned.
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
-		pub fn resign_candidate(origin: OriginFor<T>) -> DispatchResult {
+		pub fn resign_candidacy(origin: OriginFor<T>) -> DispatchResult {
 			let candidate = ensure_signed(origin)?;
-			let candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
-			ensure!(!candidacy.tally.more_approvals(), Error::<T, I>::Approved);
-			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
-			Self::check_skeptic(&candidate, &candidacy);
+			let mut candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			if !Self::in_progress(candidacy.round) {
+				Self::check_skeptic(&candidate, &mut candidacy);
+			}
+			Self::reject_candidate(&candidate, &candidacy.kind);
 			Votes::<T, I>::remove_prefix(&candidate, None);
 			Candidates::<T, I>::remove(&candidate);
 			Ok(())
 		}
 
 		/// Remove a `candidate`'s failed application from the society. Callable by any
-		/// signed origin but only after the subsequent period for voting has ended.
+		/// signed origin but only at the end of the subsequent round and only for
+		/// a candidate with more rejections than approvals.
+		///
+		/// The bid deposit is lost and the voucher is banned.
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
 		pub fn drop_candidate(origin: OriginFor<T>, candidate: T::AccountId) -> DispatchResult {
 			ensure_signed(origin)?;
 			let candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
-			ensure!(!candidacy.tally.more_approvals(), Error::<T, I>::Approved);
+			ensure!(candidacy.tally.clear_rejection(), Error::<T, I>::NotRejected);
 			ensure!(RoundCount::<T, I>::get() > candidacy.round + 1, Error::<T, I>::TooEarly);
+			Self::reject_candidate(&candidate, &candidacy.kind);
 			Votes::<T, I>::remove_prefix(&candidate, None);
 			Candidates::<T, I>::remove(&candidate);
 			Ok(())
@@ -1356,20 +1398,22 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		Vote { approve, weight }
 	}
 
-	fn check_skeptic(candidate: &T::AccountId, candidacy: &Candidacy<T::AccountId, BalanceOf<T, I>>) {
-		if RoundCount::<T, I>::get() != candidacy.round { return }
+	fn check_skeptic(candidate: &T::AccountId, candidacy: &mut Candidacy<T::AccountId, BalanceOf<T, I>>) {
+		if RoundCount::<T, I>::get() != candidacy.round || candidacy.skeptic_struck { return }
 		// We expect the skeptic to have voted.
 		let skeptic = match Skeptic::<T, I>::get() { Some(s) => s, None => return };
 		let maybe_vote = Votes::<T, I>::get(&candidate, &skeptic);
-		let approved = candidacy.tally.more_approvals();
-		let rejected = candidacy.tally.more_rejections();
+		let approved = candidacy.tally.clear_approval();
+		let rejected = candidacy.tally.clear_rejection();
 		match (maybe_vote, approved, rejected) {
 			(None, _, _)
 			| (Some(Vote { approve: true, .. }), false, true)
 			| (Some(Vote { approve: false, .. }), true, false)
 			=> {
 				// Can't do much if the punishment doesn't work out.
-				let _ = Self::strike_member(&skeptic);
+				if Self::strike_member(&skeptic).is_ok() {
+					candidacy.skeptic_struck = true;
+				}
 			},
 			_ => {},
 		}
@@ -1489,6 +1533,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 					kind: bid.kind.clone(),
 					bid: bid.value,
 					tally: Default::default(),
+					skeptic_struck: false,
 				};
 				Candidates::<T, I>::insert(&bid.who, candidacy);
 				selections.saturating_inc();
@@ -1537,6 +1582,26 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		}
 	}
 
+	/// Either repatriate the deposit into the Society account or ban the vouching member.
+	///
+	/// In neither case can we do much if the action isn't completable, but there's
+	/// no reason that either should fail.
+	///
+	/// WARNING: This alters the voucher item of `Members`. You must ensure that you do not
+	/// accidentally overwrite it with an older value after calling this.
+	fn reject_candidate(who: &T::AccountId, kind: &BidKind<T::AccountId, BalanceOf<T, I>>) {
+		match kind {
+			BidKind::Deposit(deposit) => {
+				let pot = Self::account_id();
+				let free = BalanceStatus::Free;
+				debug_assert!(T::Currency::repatriate_reserved(&who, &pot, *deposit, free).is_ok());
+			},
+			BidKind::Vouch(voucher, _) => {
+				Members::<T, I>::mutate_extant(voucher, |record| record.vouching = Some(VouchingStatus::Banned));
+			},
+		}
+	}
+
 	/// Check a user has a bid.
 	fn has_bid(bids: &Vec<Bid<T::AccountId, BalanceOf<T, I>>>, who: &T::AccountId) -> bool {
 		// Bids are ordered by `value`, so we cannot binary search for a user.
@@ -1581,10 +1646,10 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	/// Induct a new member into the set.
 	fn induct_member(
 		candidate: T::AccountId,
-		candidacy: Candidacy<T::AccountId, BalanceOf<T, I>>,
+		mut candidacy: Candidacy<T::AccountId, BalanceOf<T, I>>,
 		rank: Rank,
 	) -> DispatchResult {
-		Self::check_skeptic(&candidate, &candidacy);
+		Self::check_skeptic(&candidate, &mut candidacy);
 		Self::add_new_member(&candidate, rank)?;
 		let next_head = NextHead::<T, I>::get()
 			.filter(|old| old.round > candidacy.round
@@ -1602,18 +1667,22 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	fn strike_member(who: &T::AccountId) -> DispatchResult {
 		let mut record = Members::<T, I>::get(who).ok_or(Error::<T, I>::NotMember)?;
 		record.strikes.saturating_inc();
+		Members::<T, I>::insert(who, &record);
+		// ^^^ Keep the member record mutation self-contained as we might be suspending them later
+		// in this function.
+
 		if record.strikes >= T::GraceStrikes::get() {
 			// Too many strikes: slash the payout in half.
 			let total_payout = Payouts::<T, I>::get(who).payouts.iter()
 				.fold(BalanceOf::<T, I>::zero(), |acc, x| acc.saturating_add(x.1));
 			Self::slash_payout(who, total_payout / 2u32.into());
 		}
+
 		let params = Parameters::<T, I>::get().ok_or(Error::<T, I>::NotGroup)?;
 		if record.strikes >= params.max_strikes {
 			// Way too many strikes: suspend.
 			Self::suspend_member(who);
 		}
-		Members::<T, I>::insert(who, &record);
 		Ok(())
 	}
 
@@ -1675,6 +1744,8 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		if let Ok(record) = Self::remove_member(&who) {
 			SuspendedMembers::<T, I>::insert(who, record);
 			Self::deposit_event(Event::<T, I>::MemberSuspended { member: who.clone() });
+		} else {
+			debug_assert!(false, "Unable to remove member (is it the Head or Founder?)")
 		}
 	}
 
@@ -1772,7 +1843,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 
 	/// Bump the payout amount of `who`, to be unlocked at the given block number.
 	///
-	/// If it the caller's duty to ensure that `who` is already a member. This does nothing if `who`
+	/// It is the caller's duty to ensure that `who` is already a member. This does nothing if `who`
 	/// is not a member or if `value` is zero.
 	fn bump_payout(who: &T::AccountId, when: T::BlockNumber, value: BalanceOf<T, I>) {
 		if value.is_zero() { return }
diff --git a/frame/society/src/mock.rs b/frame/society/src/mock.rs
index d3b8e5168346d..19f08296baf8a 100644
--- a/frame/society/src/mock.rs
+++ b/frame/society/src/mock.rs
@@ -195,5 +195,5 @@ pub fn candidacy<AccountId, Balance>(
 	approvals: VoteCount,
 	rejections: VoteCount,
 ) -> Candidacy<AccountId, Balance> {
-	Candidacy { round, kind, bid, tally: Tally { approvals, rejections } }
+	Candidacy { round, kind, bid, tally: Tally { approvals, rejections }, skeptic_struck: false }
 }
diff --git a/frame/society/src/tests.rs b/frame/society/src/tests.rs
index c377bbdafb654..c3c6984851ec5 100644
--- a/frame/society/src/tests.rs
+++ b/frame/society/src/tests.rs
@@ -24,14 +24,80 @@ use frame_support::{assert_noop, assert_ok};
 use sp_core::blake2_256;
 use sp_runtime::traits::BadOrigin;
 
+fn next_voting() {
+	if let Period::Voting { more, .. } = Society::period() {
+		run_to_block(System::block_number() + more);
+	}
+}
+
+fn conclude_intake(allow_resignation: bool, judge_intake: Option<bool>) {
+	next_voting();
+	let round = RoundCount::<Test>::get();
+	for (who, candidacy) in Candidates::<Test>::iter() {
+		if candidacy.tally.clear_approval() {
+			assert_ok!(Society::claim_membership(Origin::signed(who)));
+			assert_noop!(Society::claim_membership(Origin::signed(who)), Error::<Test>::NotCandidate);
+			continue
+		}
+		if candidacy.tally.clear_rejection() && allow_resignation {
+			assert_noop!(Society::claim_membership(Origin::signed(who)), Error::<Test>::NotApproved);
+			assert_ok!(Society::resign_candidacy(Origin::signed(who)));
+			continue
+		}
+		if let (Some(founder), Some(approve)) = (Founder::<Test>::get(), judge_intake) {
+			if !candidacy.tally.clear_approval() && !approve {
+				// can be rejected by founder
+				assert_ok!(Society::kick_candidate(Origin::signed(founder), who));
+				continue
+			}
+			if !candidacy.tally.clear_rejection() && approve {
+				// can be rejected by founder
+				assert_ok!(Society::bestow_membership(Origin::signed(founder), who));
+				continue
+			}
+		}
+		if candidacy.tally.clear_rejection() && round > candidacy.round + 1 {
+			assert_noop!(Society::claim_membership(Origin::signed(who)), Error::<Test>::NotApproved);
+			assert_ok!(Society::drop_candidate(Origin::signed(0), who));
+			assert_noop!(Society::drop_candidate(Origin::signed(0), who), Error::<Test>::NotCandidate);
+			continue
+		}
+		if !candidacy.skeptic_struck {
+			assert_ok!(Society::punish_skeptic(Origin::signed(who)));
+		}
+	}
+}
+
+fn next_intake() {
+	let claim_period: u64 = <Test as Config>::ClaimPeriod::get();
+	match Society::period() {
+		Period::Voting { more, .. } => run_to_block(System::block_number() + more + claim_period),
+		Period::Claim { more, .. } => run_to_block(System::block_number() + more),
+	}
+}
+
+fn place_members(members: impl AsRef<[u128]>) {
+	for who in members.as_ref() {
+		assert_ok!(Society::insert_member(who, 0));
+	}
+}
+
 fn members() -> Vec<u128> {
 	let mut r = Members::<Test>::iter_keys().collect::<Vec<_>>();
 	r.sort();
 	r
 }
 
-fn candidates() -> Vec<(u128, Candidacy<u128, u64>)> {
-	Candidates::<Test>::iter().collect()
+fn candidacies() -> Vec<(u128, Candidacy<u128, u64>)> {
+	let mut r = Candidates::<Test>::iter().collect::<Vec<_>>();
+	r.sort_by_key(|x| x.0);
+	r
+}
+
+fn candidates() -> Vec<u128> {
+	let mut r = Candidates::<Test>::iter_keys().collect::<Vec<_>>();
+	r.sort();
+	r
 }
 
 #[test]
@@ -57,12 +123,12 @@ fn founding_works() {
 		// rules are correct
 		assert_eq!(Rules::<Test>::get(), Some(blake2_256(b"be cool").into()));
 		// Pot grows after first rotation period
-		run_to_block(4);
+		next_intake();
 		assert_eq!(Pot::<Test>::get(), 1000);
 		// Cannot start another society
 		assert_noop!(
 			Society::found_society(Origin::signed(1), 20, 100, 10, 2, 25, vec![]),
-			Error::<Test, _>::AlreadyFounded
+			Error::<Test>::AlreadyFounded
 		);
 	});
 }
@@ -73,7 +139,7 @@ fn unfounding_works() {
 		// Account 1 sets the founder...
 		assert_ok!(Society::found_society(Origin::signed(1), 10, 100, 10, 2, 25, vec![]));
 		// Account 2 cannot unfound it as it's not the founder.
-		assert_noop!(Society::dissolve(Origin::signed(2)), Error::<Test, _>::NotFounder);
+		assert_noop!(Society::dissolve(Origin::signed(2)), Error::<Test>::NotFounder);
 		// Account 10 can, though.
 		assert_ok!(Society::dissolve(Origin::signed(10)));
 
@@ -81,13 +147,12 @@ fn unfounding_works() {
 		assert_ok!(Society::found_society(Origin::signed(1), 20, 100, 10, 2, 25, vec![]));
 		// Bring in a new member...
 		assert_ok!(Society::bid(Origin::signed(10), 0));
-		run_to_block(4);
+		next_intake();
 		assert_ok!(Society::vote(Origin::signed(20), 10, true));
-		run_to_block(7);
-		assert_ok!(Society::claim_membership(Origin::signed(10)));
+		conclude_intake(true, None);
 
 		// Unfounding won't work now, even though it's from 20.
-		assert_noop!(Society::dissolve(Origin::signed(20)), Error::<Test, _>::NotHead);
+		assert_noop!(Society::dissolve(Origin::signed(20)), Error::<Test>::NotHead);
 	});
 }
 
@@ -100,15 +165,14 @@ fn basic_new_member_works() {
 		assert_eq!(Balances::free_balance(20), 25);
 		assert_eq!(Balances::reserved_balance(20), 25);
 		// Rotate period every 4 blocks
-		run_to_block(4);
+		next_intake();
 		// 20 is now a candidate
-		assert_eq!(candidates(), vec![(20, candidacy(1, 0, BidKind::Deposit(25), 0, 0))]);
+		assert_eq!(candidacies(), vec![(20, candidacy(1, 0, BidKind::Deposit(25), 0, 0))]);
 		// 10 (a member) can vote for the candidate
 		assert_ok!(Society::vote(Origin::signed(10), 20, true));
+		conclude_intake(true, None);
 		// Rotate period every 4 blocks
-		run_to_block(7);
-		assert_ok!(Society::claim_membership(Origin::signed(20)));
-		run_to_block(8);
+		next_intake();
 		// 20 is now a member of the society
 		assert_eq!(members(), vec![10, 20]);
 		// Reserved balance is returned
@@ -126,13 +190,13 @@ fn bidding_works() {
 		assert_ok!(Society::bid(Origin::signed(40), 400));
 		assert_ok!(Society::bid(Origin::signed(30), 300));
 		// Rotate period
-		run_to_block(4);
+		next_intake();
 		// Pot is 1000 after "PeriodSpend"
 		assert_eq!(Pot::<Test>::get(), 1000);
 		assert_eq!(Balances::free_balance(Society::account_id()), 10_000);
 		// Choose smallest bidding users whose total is less than pot
 		assert_eq!(
-			candidates(),
+			candidacies(),
 			vec![
 				(30, candidacy(1, 300, BidKind::Deposit(25), 0, 0)),
 				(40, candidacy(1, 400, BidKind::Deposit(25), 0, 0)),
@@ -141,21 +205,18 @@ fn bidding_works() {
 		// A member votes for these candidates to join the society
 		assert_ok!(Society::vote(Origin::signed(10), 30, true));
 		assert_ok!(Society::vote(Origin::signed(10), 40, true));
-		run_to_block(7);
-		assert_ok!(Society::claim_membership(Origin::signed(30)));
-		assert_ok!(Society::claim_membership(Origin::signed(40)));
-		run_to_block(8);
+		conclude_intake(true, None);
+		next_intake();
 		// Candidates become members after a period rotation
 		assert_eq!(members(), vec![10, 30, 40]);
 		// Pot is increased by 1000, but pays out 700 to the members
 		assert_eq!(Balances::free_balance(Society::account_id()), 9_300);
 		assert_eq!(Pot::<Test>::get(), 1_300);
 		// Left over from the original bids is 50 who satisfies the condition of bid less than pot.
-		assert_eq!(candidates(), vec![(50, candidacy(2, 500, BidKind::Deposit(25), 0, 0))]);
+		assert_eq!(candidacies(), vec![(50, candidacy(2, 500, BidKind::Deposit(25), 0, 0))]);
 		// 40, now a member, can vote for 50
 		assert_ok!(Society::vote(Origin::signed(40), 50, true));
-		run_to_block(11);
-		assert_ok!(Society::claim_membership(Origin::signed(50)));
+		conclude_intake(true, None);
 		run_to_block(12);
 		// 50 is now a member
 		assert_eq!(members(), vec![10, 30, 40, 50]);
@@ -163,7 +224,7 @@ fn bidding_works() {
 		assert_eq!(Pot::<Test>::get(), 1_800);
 		assert_eq!(Balances::free_balance(Society::account_id()), 8_800);
 		// No more candidates satisfy the requirements
-		assert_eq!(candidates(), vec![]);
+		assert_eq!(candidacies(), vec![]);
 		assert_ok!(Society::defender_vote(Origin::signed(10), true)); // Keep defender around
 		// Next period
 		run_to_block(16);
@@ -174,11 +235,10 @@ fn bidding_works() {
 		// No payouts
 		assert_eq!(Balances::free_balance(Society::account_id()), 8_800);
 		// Candidate 60 now qualifies based on the increased pot size.
-		assert_eq!(candidates(), vec![(60, candidacy(4, 1900, BidKind::Deposit(25), 0, 0))]);
+		assert_eq!(candidacies(), vec![(60, candidacy(4, 1900, BidKind::Deposit(25), 0, 0))]);
 		// Candidate 60 is voted in.
 		assert_ok!(Society::vote(Origin::signed(50), 60, true));
-		run_to_block(19);
-		assert_ok!(Society::claim_membership(Origin::signed(60)));
+		conclude_intake(true, None);
 		run_to_block(20);
 		// 60 joins as a member
 		assert_eq!(members(), vec![10, 30, 40, 50, 60]);
@@ -199,13 +259,13 @@ fn unbidding_works() {
 		assert_eq!(Balances::reserved_balance(30), 25);
 		// Can unbid themselves with the right position
 		assert_ok!(Society::unbid(Origin::signed(30)));
-		assert_noop!(Society::unbid(Origin::signed(30)), Error::<Test, _>::NotBidder);
+		assert_noop!(Society::unbid(Origin::signed(30)), Error::<Test>::NotBidder);
 		// Balance is returned
 		assert_eq!(Balances::free_balance(30), 50);
 		assert_eq!(Balances::reserved_balance(30), 0);
 		// 20 wins candidacy
-		run_to_block(4);
-		assert_eq!(candidates(), vec![(20, candidacy(1, 1000, BidKind::Deposit(25), 0, 0))]);
+		next_intake();
+		assert_eq!(candidacies(), vec![(20, candidacy(1, 1000, BidKind::Deposit(25), 0, 0))]);
 	});
 }
 
@@ -215,13 +275,12 @@ fn payout_works() {
 		// Original balance of 50
 		assert_eq!(Balances::free_balance(20), 50);
 		assert_ok!(Society::bid(Origin::signed(20), 1000));
-		run_to_block(4);
+		next_intake();
 		assert_ok!(Society::vote(Origin::signed(10), 20, true));
-		run_to_block(7);
-		assert_ok!(Society::claim_membership(Origin::signed(20)));
+		conclude_intake(true, None);
 		// payout not ready
-		assert_noop!(Society::payout(Origin::signed(20)), Error::<Test, _>::NoPayout);
-		run_to_block(8);
+		assert_noop!(Society::payout(Origin::signed(20)), Error::<Test>::NoPayout);
+		next_intake();
 		// payout should be here
 		assert_ok!(Society::payout(Origin::signed(20)));
 		assert_eq!(Balances::free_balance(20), 1050);
@@ -233,12 +292,10 @@ fn non_voting_skeptic_is_punished() {
 	EnvBuilder::new().execute(|| {
 		assert_eq!(Members::<Test>::get(10).unwrap().strikes, 0);
 		assert_ok!(Society::bid(Origin::signed(20), 0));
-		run_to_block(4);
-		assert_eq!(candidates(), vec![(20, candidacy(1, 0, BidKind::Deposit(25), 0, 0))]);
-		run_to_block(7);
-		assert_noop!(Society::claim_membership(Origin::signed(20)), Error::<Test>::NotApproved);
-		assert_ok!(Society::resign_candidate(Origin::signed(20)));
-		run_to_block(8);
+		next_intake();
+		assert_eq!(candidacies(), vec![(20, candidacy(1, 0, BidKind::Deposit(25), 0, 0))]);
+		conclude_intake(true, None);
+		next_intake();
 		assert_eq!(members(), vec![10]);
 		assert_eq!(Members::<Test>::get(10).unwrap().strikes, 1);
 	});
@@ -247,31 +304,21 @@ fn non_voting_skeptic_is_punished() {
 #[test]
 fn rejecting_skeptic_on_approved_is_punished() {
 	EnvBuilder::new().execute(|| {
-		assert_eq!(Members::<Test>::get(10).unwrap().strikes, 0);
-		assert_ok!(Society::bid(Origin::signed(20), 0));
-		assert_ok!(Society::bid(Origin::signed(30), 1));
-		run_to_block(4);
+		place_members([20, 30]);
 		assert_ok!(Society::bid(Origin::signed(40), 0));
-
-		assert_ok!(Society::vote(Origin::signed(10), 20, true));
-		assert_ok!(Society::vote(Origin::signed(10), 30, true));
-		run_to_block(7);
-		assert_ok!(Society::claim_membership(Origin::signed(20)));
-		assert_ok!(Society::claim_membership(Origin::signed(30)));
-		run_to_block(8);
+		next_intake();
 		let skeptic = Skeptic::<Test>::get().unwrap();
 		for &i in &[10, 20, 30][..] {
 			assert_ok!(Society::vote(Origin::signed(i), 40, i != skeptic));
 		}
-		run_to_block(11);
-		assert_ok!(Society::claim_membership(Origin::signed(40)));
+		conclude_intake(true, None);
+		assert_eq!(Members::<Test>::get(10).unwrap().strikes, 0);
 		run_to_block(12);
 		assert_eq!(members(), vec![10, 20, 30, 40]);
 		assert_eq!(Members::<Test>::get(skeptic).unwrap().strikes, 1);
 	});
 }
 
-/*
 #[test]
 fn basic_new_member_reject_works() {
 	EnvBuilder::new().execute(|| {
@@ -282,16 +329,17 @@ fn basic_new_member_reject_works() {
 		assert_eq!(Balances::free_balance(20), 25);
 		assert_eq!(Balances::reserved_balance(20), 25);
 		// Rotation Period
-		run_to_block(4);
-		assert_eq!(candidates(), vec![(20, candidacy(1, 0, BidKind::Deposit(25), 0, 0))]);
+		next_intake();
+		assert_eq!(candidacies(), vec![(20, candidacy(1, 0, BidKind::Deposit(25), 0, 0))]);
 		// We say no
 		assert_ok!(Society::vote(Origin::signed(10), 20, false));
-		run_to_block(8);
+		conclude_intake(true, None);
+		next_intake();
 		// User is not added as member
 		assert_eq!(members(), vec![10]);
-		// User is suspended
-		assert_eq!(candidates(), vec![]);
-		assert_eq!(Society::suspended_candidate(20).is_some(), true);
+		// User is rejected.
+		assert_eq!(candidacies(), vec![]);
+		assert_eq!(Bids::<Test>::get(), vec![]);
 	});
 }
 
@@ -300,19 +348,20 @@ fn slash_payout_works() {
 	EnvBuilder::new().execute(|| {
 		assert_eq!(Balances::free_balance(20), 50);
 		assert_ok!(Society::bid(Origin::signed(20), 1000));
-		run_to_block(4);
+		next_intake();
 		assert_ok!(Society::vote(Origin::signed(10), 20, true));
-		run_to_block(8);
+		conclude_intake(true, None);
 		// payout in queue
-		assert_eq!(Payouts::<Test>::get(20), vec![(9, 1000)]);
-		assert_noop!(Society::payout(Origin::signed(20)), Error::<Test, _>::NoPayout);
+		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(8, 1000)].try_into().unwrap() });
+		assert_noop!(Society::payout(Origin::signed(20)), Error::<Test>::NoPayout);
 		// slash payout
 		assert_eq!(Society::slash_payout(&20, 500), 500);
-		assert_eq!(Payouts::<Test>::get(20), vec![(9, 500)]);
-		run_to_block(9);
+		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(8, 500)].try_into().unwrap() });
+		run_to_block(8);
 		// payout should be here, but 500 less
 		assert_ok!(Society::payout(Origin::signed(20)));
 		assert_eq!(Balances::free_balance(20), 550);
+		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 500, payouts: Default::default() });
 	});
 }
 
@@ -320,19 +369,20 @@ fn slash_payout_works() {
 fn slash_payout_multi_works() {
 	EnvBuilder::new().execute(|| {
 		assert_eq!(Balances::free_balance(20), 50);
+		place_members([20]);
 		// create a few payouts
 		Society::bump_payout(&20, 5, 100);
 		Society::bump_payout(&20, 10, 100);
 		Society::bump_payout(&20, 15, 100);
 		Society::bump_payout(&20, 20, 100);
 		// payouts in queue
-		assert_eq!(Payouts::<Test>::get(20), vec![(5, 100), (10, 100), (15, 100), (20, 100)]);
+		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(5, 100), (10, 100), (15, 100), (20, 100)].try_into().unwrap() });
 		// slash payout
 		assert_eq!(Society::slash_payout(&20, 250), 250);
-		assert_eq!(Payouts::<Test>::get(20), vec![(15, 50), (20, 100)]);
+		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(15, 50), (20, 100)].try_into().unwrap() });
 		// slash again
 		assert_eq!(Society::slash_payout(&20, 50), 50);
-		assert_eq!(Payouts::<Test>::get(20), vec![(20, 100)]);
+		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(20, 100)].try_into().unwrap() });
 	});
 }
 
@@ -340,132 +390,153 @@ fn slash_payout_multi_works() {
 fn suspended_member_life_cycle_works() {
 	EnvBuilder::new().execute(|| {
 		// Add 20 to members, who is not the head and can be suspended/removed.
-		assert_ok!(Society::add_member(&20));
-		assert_eq!(<Members<Test>>::get(), vec![10, 20]);
-		assert_eq!(Strikes::<Test>::get(20), 0);
-		assert_eq!(<SuspendedMembers<Test>>::get(20), false);
+		place_members([20]);
+		assert_eq!(members(), vec![10, 20]);
+		assert_eq!(Members::<Test>::get(20).unwrap().strikes, 0);
+		assert!(!SuspendedMembers::<Test>::contains_key(20));
 
 		// Let's suspend account 20 by giving them 2 strikes by not voting
 		assert_ok!(Society::bid(Origin::signed(30), 0));
-		run_to_block(8);
-		assert_eq!(Strikes::<Test>::get(20), 1);
-		assert_ok!(Society::bid(Origin::signed(40), 0));
-		run_to_block(16);
+		assert_ok!(Society::bid(Origin::signed(40), 1));
+		next_intake();
+		conclude_intake(false, None);
+
 
-		// Strike 2 is accumulated, and 20 is suspended :(
-		assert_eq!(<SuspendedMembers<Test>>::get(20), true);
-		assert_eq!(<Members<Test>>::get(), vec![10]);
+		// 2 strikes are accumulated, and 20 is suspended :(
+		assert!(SuspendedMembers::<Test>::contains_key(20));
+		assert_eq!(members(), vec![10]);
 
 		// Suspended members cannot get payout
 		Society::bump_payout(&20, 10, 100);
-		assert_noop!(Society::payout(Origin::signed(20)), Error::<Test, _>::NotMember);
+		assert_noop!(Society::payout(Origin::signed(20)), Error::<Test>::NotMember);
 
 		// Normal people cannot make judgement
-		assert_noop!(Society::judge_suspended_member(Origin::signed(20), 20, true), BadOrigin);
+		assert_noop!(Society::judge_suspended_member(Origin::signed(20), 20, true), Error::<Test>::NotFounder);
 
 		// Suspension judgment origin can judge thee
 		// Suspension judgement origin forgives the suspended member
-		assert_ok!(Society::judge_suspended_member(Origin::signed(2), 20, true));
-		assert_eq!(<SuspendedMembers<Test>>::get(20), false);
-		assert_eq!(<Members<Test>>::get(), vec![10, 20]);
+		assert_ok!(Society::judge_suspended_member(Origin::signed(10), 20, true));
+		assert!(!SuspendedMembers::<Test>::contains_key(20));
+		assert_eq!(members(), vec![10, 20]);
 
 		// Let's suspend them again, directly
 		Society::suspend_member(&20);
-		assert_eq!(<SuspendedMembers<Test>>::get(20), true);
+		assert!(SuspendedMembers::<Test>::contains_key(20));
 		// Suspension judgement origin does not forgive the suspended member
-		assert_ok!(Society::judge_suspended_member(Origin::signed(2), 20, false));
+		assert_ok!(Society::judge_suspended_member(Origin::signed(10), 20, false));
 		// Cleaned up
-		assert_eq!(<SuspendedMembers<Test>>::get(20), false);
-		assert_eq!(<Members<Test>>::get(), vec![10]);
-		assert_eq!(<Payouts<Test>>::get(20), vec![]);
+		assert!(!SuspendedMembers::<Test>::contains_key(20));
+		assert_eq!(members(), vec![10]);
+		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![].try_into().unwrap() });
 	});
 }
 
 #[test]
 fn suspended_candidate_rejected_works() {
 	EnvBuilder::new().execute(|| {
-		// Starting Balance
-		assert_eq!(Balances::free_balance(20), 50);
-		assert_eq!(Balances::free_balance(Society::account_id()), 10000);
-		// 20 makes a bid
-		assert_ok!(Society::bid(Origin::signed(20), 0));
-		assert_eq!(Balances::free_balance(20), 25);
-		assert_eq!(Balances::reserved_balance(20), 25);
+		place_members([20, 30]);
+		// 40, 50, 60, 70, 80 make bids
+		for &x in &[40u128, 50, 60, 70] {
+			assert_ok!(Society::bid(Origin::signed(x), 10));
+			assert_eq!(Balances::free_balance(x), 25);
+			assert_eq!(Balances::reserved_balance(x), 25);
+		}
+
 		// Rotation Period
-		run_to_block(4);
-		assert_eq!(candidates(), vec![(20, candidacy(1, 0, BidKind::Deposit(25), 0, 0))]);
-		// We say no
-		assert_ok!(Society::vote(Origin::signed(10), 20, false));
-		run_to_block(8);
-		// User is not added as member
-		assert_eq!(members(), vec![10]);
-		// User is suspended
-		assert_eq!(candidates(), vec![]);
-		assert_eq!(Society::suspended_candidate(20).is_some(), true);
+		next_intake();
+		assert_eq!(candidacies(), vec![
+			(40, candidacy(1, 10, BidKind::Deposit(25), 0, 0)),
+			(50, candidacy(1, 10, BidKind::Deposit(25), 0, 0)),
+			(60, candidacy(1, 10, BidKind::Deposit(25), 0, 0)),
+			(70, candidacy(1, 10, BidKind::Deposit(25), 0, 0)),
+		]);
 
-		// Normal user cannot make judgement on suspended candidate
-		assert_noop!(
-			Society::judge_suspended_candidate(Origin::signed(20), 20, Judgement::Approve),
-			BadOrigin
-		);
+		// Split vote over all.
+		for &x in &[40, 50, 60, 70] {
+			assert_ok!(Society::vote(Origin::signed(20), x, false));
+			assert_ok!(Society::vote(Origin::signed(30), x, true));
+		}
 
-		// Suspension judgement origin makes no direct judgement
-		assert_ok!(Society::judge_suspended_candidate(Origin::signed(2), 20, Judgement::Rebid));
-		// They are placed back in bid pool, repeat suspension process
-		// Rotation Period
-		run_to_block(12);
-		assert_eq!(candidates(), vec![(20, candidacy(1, 0, BidKind::Deposit(25), 0, 0))]);
-		// We say no
-		assert_ok!(Society::vote(Origin::signed(10), 20, false));
-		run_to_block(16);
-		// User is not added as member
-		assert_eq!(members(), vec![10]);
-		// User is suspended
-		assert_eq!(candidates(), vec![]);
-		assert_eq!(Society::suspended_candidate(20).is_some(), true);
+		// Voting continues, as no canidate is clearly accepted yet and the founder chooses not to
+		// act.
+		conclude_intake(false, None);
+		assert_eq!(members(), vec![10, 20, 30]);
+		assert_eq!(candidates(), vec![40, 50, 60, 70]);
 
-		// Suspension judgement origin rejects the candidate
-		assert_ok!(Society::judge_suspended_candidate(Origin::signed(2), 20, Judgement::Reject));
-		// User is slashed
-		assert_eq!(Balances::free_balance(20), 25);
-		assert_eq!(Balances::reserved_balance(20), 0);
-		// Funds are deposited to society account
-		assert_eq!(Balances::free_balance(Society::account_id()), 10025);
-		// Cleaned up
+		// 40 gets approved after founder weighs in giving it a clear approval.
+		// but the founder's rejection of 60 doesn't do much for now.
+		assert_ok!(Society::vote(Origin::signed(10), 40, true));
+		assert_ok!(Society::vote(Origin::signed(10), 60, false));
+		conclude_intake(false, None);
+		assert_eq!(members(), vec![10, 20, 30, 40]);
+		assert_eq!(candidates(), vec![50, 60, 70]);
+		assert_eq!(Balances::free_balance(40), 50);
+		assert_eq!(Balances::reserved_balance(40), 0);
+		assert_eq!(Balances::free_balance(Society::account_id()), 9990);
+
+		// Founder manually bestows membership on 50 and and kicks 70.
+		assert_ok!(Society::bestow_membership(Origin::signed(10), 50));
+		assert_eq!(members(), vec![10, 20, 30, 40, 50]);
+		assert_eq!(candidates(), vec![60, 70]);
+		assert_eq!(Balances::free_balance(50), 50);
+		assert_eq!(Balances::reserved_balance(50), 0);
+		assert_eq!(Balances::free_balance(Society::account_id()), 9980);
+
+		assert_ok!(Society::kick_candidate(Origin::signed(10), 70));
+		assert_eq!(members(), vec![10, 20, 30, 40, 50]);
+		assert_eq!(candidates(), vec![60]);
+		assert_eq!(Balances::free_balance(70), 25);
+		assert_eq!(Balances::reserved_balance(70), 0);
+		assert_eq!(Balances::free_balance(Society::account_id()), 10005);
+
+		// Next round doesn't make much difference.
+		next_intake();
+		conclude_intake(false, None);
+		assert_eq!(members(), vec![10, 20, 30, 40, 50]);
+		assert_eq!(candidates(), vec![60]);
+		assert_eq!(Balances::free_balance(Society::account_id()), 10005);
+
+		// But after two rounds, the clearly rejected 60 gets dropped and slashed.
+		next_intake();
+		conclude_intake(false, None);
+		assert_eq!(members(), vec![10, 20, 30, 40, 50]);
 		assert_eq!(candidates(), vec![]);
-		assert_eq!(<SuspendedCandidates<Test>>::get(20), None);
+		assert_eq!(Balances::free_balance(60), 25);
+		assert_eq!(Balances::reserved_balance(60), 0);
+		assert_eq!(Balances::free_balance(Society::account_id()), 10030);
 	});
 }
 
+/*
 #[test]
 fn vouch_works() {
 	EnvBuilder::new().execute(|| {
 		// 10 is the only member
 		assert_eq!(members(), vec![10]);
 		// A non-member cannot vouch
-		assert_noop!(Society::vouch(Origin::signed(1), 20, 1000, 100), Error::<Test, _>::NotMember);
+		assert_noop!(Society::vouch(Origin::signed(1), 20, 1000, 100), Error::<Test>::NotMember);
 		// A member can though
 		assert_ok!(Society::vouch(Origin::signed(10), 20, 1000, 100));
 		assert_eq!(<Vouching<Test>>::get(10), Some(VouchingStatus::Vouching));
 		// A member cannot vouch twice at the same time
 		assert_noop!(
 			Society::vouch(Origin::signed(10), 30, 100, 0),
-			Error::<Test, _>::AlreadyVouching
+			Error::<Test>::AlreadyVouching
 		);
 		// Vouching creates the right kind of bid
 		assert_eq!(<Bids<Test>>::get(), vec![(20, candidacy(1, 1000, BidKind::Vouch(10,, 0, 0) 100))]);
 		// Vouched user can become candidate
-		run_to_block(4);
-		assert_eq!(candidates(), vec![(20, candidacy(1, 1000, BidKind::Vouch(10,, 0, 0) 100))]);
+		next_intake();
+		assert_eq!(candidacies(), vec![(20, candidacy(1, 1000, BidKind::Vouch(10,, 0, 0) 100))]);
 		// Vote yes
 		assert_ok!(Society::vote(Origin::signed(10), 20, true));
 		// Vouched user can win
-		run_to_block(8);
+		next_intake();
 		assert_eq!(members(), vec![10, 20]);
 		// Voucher wins a portion of the payment
-		assert_eq!(<Payouts<Test>>::get(10), vec![(9, 100)]);
+		assert_eq!(Payouts::<Test>::get(10), PayoutRecord { paid: 0, payouts: vec![(9, 100)].try_into().unwrap() });
 		// Vouched user wins the rest
-		assert_eq!(<Payouts<Test>>::get(20), vec![(9, 900)]);
+		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(9, 900)].try_into().unwrap() });
 		// 10 is no longer vouching
 		assert_eq!(<Vouching<Test>>::get(10), None);
 	});
@@ -481,17 +552,17 @@ fn voucher_cannot_win_more_than_bid() {
 		// Vouching creates the right kind of bid
 		assert_eq!(<Bids<Test>>::get(), vec![(20, candidacy(1, 100, BidKind::Vouch(10,, 0, 0) 1000))]);
 		// Vouched user can become candidate
-		run_to_block(4);
-		assert_eq!(candidates(), vec![(20, candidacy(1, 100, BidKind::Vouch(10,, 0, 0) 1000))]);
+		next_intake();
+		assert_eq!(candidacies(), vec![(20, candidacy(1, 100, BidKind::Vouch(10,, 0, 0) 1000))]);
 		// Vote yes
 		assert_ok!(Society::vote(Origin::signed(10), 20, true));
 		// Vouched user can win
-		run_to_block(8);
+		next_intake();
 		assert_eq!(members(), vec![10, 20]);
 		// Voucher wins as much as the bid
-		assert_eq!(<Payouts<Test>>::get(10), vec![(9, 100)]);
+		assert_eq!(Payouts::<Test>::get(10), PayoutRecord { paid: 0, payouts: vec![(9, 100)].try_into().unwrap() });
 		// Vouched user gets nothing
-		assert_eq!(<Payouts<Test>>::get(20), vec![]);
+		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![].try_into().unwrap() });
 	});
 }
 
@@ -507,7 +578,7 @@ fn unvouch_works() {
 		// 10 is vouched
 		assert_eq!(<Vouching<Test>>::get(10), Some(VouchingStatus::Vouching));
 		// To unvouch, you must know the right bid position
-		assert_noop!(Society::unvouch(Origin::signed(10), 2), Error::<Test, _>::BadPosition);
+		assert_noop!(Society::unvouch(Origin::signed(10), 2), Error::<Test>::BadPosition);
 		// 10 can unvouch with the right position
 		assert_ok!(Society::unvouch(Origin::signed(10), 0));
 		// 20 no longer has a bid
@@ -517,12 +588,12 @@ fn unvouch_works() {
 
 		// Cannot unvouch after they become candidate
 		assert_ok!(Society::vouch(Origin::signed(10), 20, 100, 0));
-		run_to_block(4);
-		assert_eq!(candidates(), vec![(20, candidacy(1, 100, BidKind::Vouch(10,, 0, 0) 0))]);
-		assert_noop!(Society::unvouch(Origin::signed(10), 0), Error::<Test, _>::BadPosition);
+		next_intake();
+		assert_eq!(candidacies(), vec![(20, candidacy(1, 100, BidKind::Vouch(10,, 0, 0) 0))]);
+		assert_noop!(Society::unvouch(Origin::signed(10), 0), Error::<Test>::BadPosition);
 		// 10 is still vouching until candidate is approved or rejected
 		assert_eq!(<Vouching<Test>>::get(10), Some(VouchingStatus::Vouching));
-		run_to_block(8);
+		next_intake();
 		// In this case candidate is denied and suspended
 		assert!(Society::suspended_candidate(&20).is_some());
 		assert_eq!(members(), vec![10]);
@@ -537,10 +608,10 @@ fn unvouch_works() {
 		// 10 cannot vouch again
 		assert_noop!(
 			Society::vouch(Origin::signed(10), 30, 100, 0),
-			Error::<Test, _>::AlreadyVouching
+			Error::<Test>::AlreadyVouching
 		);
 		// 10 cannot unvouch either, so they are banned forever.
-		assert_noop!(Society::unvouch(Origin::signed(10), 0), Error::<Test, _>::NotVouching);
+		assert_noop!(Society::unvouch(Origin::signed(10), 0), Error::<Test>::NotVouching);
 	});
 }
 
@@ -572,15 +643,15 @@ fn founder_and_head_cannot_be_removed() {
 		assert_eq!(Head::<Test>::get(), Some(10));
 		// 10 can still accumulate strikes
 		assert_ok!(Society::bid(Origin::signed(20), 0));
-		run_to_block(8);
-		assert_eq!(Strikes::<Test>::get(10), 1);
+		next_intake();
+		assert_eq!(Members::<Test>::get(10).unwrap().strikes, 1);
 		assert_ok!(Society::bid(Origin::signed(30), 0));
 		run_to_block(16);
-		assert_eq!(Strikes::<Test>::get(10), 2);
+		assert_eq!(Members::<Test>::get(10).unwrap().strikes, 2);
 		// Awkwardly they can obtain more than MAX_STRIKES...
 		assert_ok!(Society::bid(Origin::signed(40), 0));
 		run_to_block(24);
-		assert_eq!(Strikes::<Test>::get(10), 3);
+		assert_eq!(Members::<Test>::get(10).unwrap().strikes, 3);
 
 		// Replace the head
 		assert_ok!(Society::bid(Origin::signed(50), 0));
@@ -596,10 +667,10 @@ fn founder_and_head_cannot_be_removed() {
 		// 50 can still accumulate strikes
 		assert_ok!(Society::bid(Origin::signed(60), 0));
 		run_to_block(40);
-		assert_eq!(Strikes::<Test>::get(50), 1);
+		assert_eq!(Members::<Test>::get(50).unwrap().strikes, 1);
 		assert_ok!(Society::bid(Origin::signed(70), 0));
 		run_to_block(48);
-		assert_eq!(Strikes::<Test>::get(50), 2);
+		assert_eq!(Members::<Test>::get(50).unwrap().strikes, 2);
 
 		// Replace the head
 		assert_ok!(Society::bid(Origin::signed(80), 0));
@@ -618,8 +689,8 @@ fn founder_and_head_cannot_be_removed() {
 		// The candidate is rejected, so voting approve will give a strike
 		assert_ok!(Society::vote(Origin::signed(50), 90, true));
 		run_to_block(64);
-		assert_eq!(Strikes::<Test>::get(50), 0);
-		assert_eq!(<SuspendedMembers<Test>>::get(50), true);
+		assert_eq!(Members::<Test>::get(50).unwrap().strikes, 0);
+		assert_eq!(SuspendedMembers::<Test>::contains_key(50), true);
 		assert_eq!(members(), vec![10, 80]);
 	});
 }
@@ -640,7 +711,7 @@ fn challenges_work() {
 		assert_eq!(members(), vec![10, 20, 30, 40]);
 		assert_eq!(Society::defender(), None);
 		// 20 will be challenged during the challenge rotation
-		run_to_block(8);
+		next_intake();
 		assert_eq!(Society::defender(), Some(30));
 		// They can always free vote for themselves
 		assert_ok!(Society::defender_vote(Origin::signed(30), true));
@@ -650,7 +721,7 @@ fn challenges_work() {
 		// New challenge period
 		assert_eq!(Society::defender(), Some(30));
 		// Non-member cannot challenge
-		assert_noop!(Society::defender_vote(Origin::signed(1), true), Error::<Test, _>::NotMember);
+		assert_noop!(Society::defender_vote(Origin::signed(1), true), Error::<Test>::NotMember);
 		// 3 people say accept, 1 reject
 		assert_ok!(Society::defender_vote(Origin::signed(10), true));
 		assert_ok!(Society::defender_vote(Origin::signed(20), true));
@@ -699,28 +770,28 @@ fn bad_vote_slash_works() {
 		Society::bump_payout(&40, 5, 100);
 		// Check starting point
 		assert_eq!(members(), vec![10, 20, 30, 40]);
-		assert_eq!(<Payouts<Test>>::get(10), vec![(5, 100)]);
-		assert_eq!(<Payouts<Test>>::get(20), vec![(5, 100)]);
-		assert_eq!(<Payouts<Test>>::get(30), vec![(5, 100)]);
-		assert_eq!(<Payouts<Test>>::get(40), vec![(5, 100)]);
+		assert_eq!(Payouts::<Test>::get(10), PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() });
+		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() });
+		assert_eq!(Payouts::<Test>::get(30), PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() });
+		assert_eq!(Payouts::<Test>::get(40), PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() });
 		// Create a new bid
 		assert_ok!(Society::bid(Origin::signed(50), 1000));
-		run_to_block(4);
+		next_intake();
 		assert_ok!(Society::vote(Origin::signed(10), 50, false));
 		assert_ok!(Society::vote(Origin::signed(20), 50, true));
 		assert_ok!(Society::vote(Origin::signed(30), 50, false));
 		assert_ok!(Society::vote(Origin::signed(40), 50, false));
-		run_to_block(8);
+		next_intake();
 		// Wrong voter gained a strike
 		assert_eq!(<Strikes<Test>>::get(10), 0);
 		assert_eq!(<Strikes<Test>>::get(20), 1);
 		assert_eq!(<Strikes<Test>>::get(30), 0);
 		assert_eq!(<Strikes<Test>>::get(40), 0);
 		// Their payout is slashed, a random person is rewarded
-		assert_eq!(<Payouts<Test>>::get(10), vec![(5, 100), (9, 2)]);
-		assert_eq!(<Payouts<Test>>::get(20), vec![(5, 98)]);
-		assert_eq!(<Payouts<Test>>::get(30), vec![(5, 100)]);
-		assert_eq!(<Payouts<Test>>::get(40), vec![(5, 100)]);
+		assert_eq!(Payouts::<Test>::get(10), PayoutRecord { paid: 0, payouts: vec![(5, 100), (9, 2)].try_into().unwrap() });
+		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(5, 98)].try_into().unwrap() });
+		assert_eq!(Payouts::<Test>::get(30), PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() });
+		assert_eq!(Payouts::<Test>::get(40), PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() });
 	});
 }
 
@@ -729,15 +800,15 @@ fn user_cannot_bid_twice() {
 	EnvBuilder::new().execute(|| {
 		// Cannot bid twice
 		assert_ok!(Society::bid(Origin::signed(20), 100));
-		assert_noop!(Society::bid(Origin::signed(20), 100), Error::<Test, _>::AlreadyBid);
+		assert_noop!(Society::bid(Origin::signed(20), 100), Error::<Test>::AlreadyBid);
 		// Cannot bid when vouched
 		assert_ok!(Society::vouch(Origin::signed(10), 30, 100, 100));
-		assert_noop!(Society::bid(Origin::signed(30), 100), Error::<Test, _>::AlreadyBid);
+		assert_noop!(Society::bid(Origin::signed(30), 100), Error::<Test>::AlreadyBid);
 		// Cannot vouch when already bid
 		assert_ok!(Society::add_member(&50));
 		assert_noop!(
 			Society::vouch(Origin::signed(50), 20, 100, 100),
-			Error::<Test, _>::AlreadyBid
+			Error::<Test>::AlreadyBid
 		);
 	});
 }
@@ -754,7 +825,7 @@ fn vouching_handles_removed_member_with_bid() {
 		assert_eq!(<Vouching<Test>>::get(20), Some(VouchingStatus::Vouching));
 		// Suspend that member
 		Society::suspend_member(&20);
-		assert_eq!(<SuspendedMembers<Test>>::get(20), true);
+		assert_eq!(SuspendedMembers::<Test>::contains_key(20), true);
 		// Nothing changes yet
 		assert_eq!(<Bids<Test>>::get(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20,, 0, 0) 100))]);
 		assert_eq!(<Vouching<Test>>::get(20), Some(VouchingStatus::Vouching));
@@ -777,26 +848,26 @@ fn vouching_handles_removed_member_with_candidate() {
 		assert_eq!(<Bids<Test>>::get(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20,, 0, 0) 100))]);
 		assert_eq!(<Vouching<Test>>::get(20), Some(VouchingStatus::Vouching));
 		// Make that bid a candidate
-		run_to_block(4);
-		assert_eq!(candidates(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20,, 0, 0) 100))]);
+		next_intake();
+		assert_eq!(candidacies(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20,, 0, 0) 100))]);
 		// Suspend that member
 		Society::suspend_member(&20);
-		assert_eq!(<SuspendedMembers<Test>>::get(20), true);
+		assert_eq!(SuspendedMembers::<Test>::contains_key(20), true);
 		// Nothing changes yet
-		assert_eq!(candidates(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20,, 0, 0) 100))]);
+		assert_eq!(candidacies(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20,, 0, 0) 100))]);
 		assert_eq!(<Vouching<Test>>::get(20), Some(VouchingStatus::Vouching));
 		// Remove member
 		assert_ok!(Society::judge_suspended_member(Origin::signed(2), 20, false));
 		// Vouching status is removed, but candidate is still in the queue
 		assert_eq!(<Vouching<Test>>::get(20), None);
-		assert_eq!(candidates(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20,, 0, 0) 100))]);
+		assert_eq!(candidacies(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20,, 0, 0) 100))]);
 		// Candidate wins
 		assert_ok!(Society::vote(Origin::signed(10), 30, true));
-		run_to_block(8);
+		next_intake();
 		assert_eq!(members(), vec![10, 30]);
 		// Payout does not go to removed member
-		assert_eq!(<Payouts<Test>>::get(20), vec![]);
-		assert_eq!(<Payouts<Test>>::get(30), vec![(9, 1000)]);
+		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![].try_into().unwrap() });
+		assert_eq!(Payouts::<Test>::get(30), PayoutRecord { paid: 0, payouts: vec![(9, 1000)].try_into().unwrap() });
 	});
 }
 
@@ -808,17 +879,17 @@ fn votes_are_working() {
 		assert_ok!(Society::bid(Origin::signed(40), 400));
 		assert_ok!(Society::bid(Origin::signed(30), 300));
 		// Rotate period
-		run_to_block(4);
+		next_intake();
 		// A member votes for these candidates to join the society
 		assert_ok!(Society::vote(Origin::signed(10), 30, true));
 		assert_ok!(Society::vote(Origin::signed(10), 40, true));
 		// You cannot vote for a non-candidate
-		assert_noop!(Society::vote(Origin::signed(10), 50, true), Error::<Test, _>::NotCandidate);
+		assert_noop!(Society::vote(Origin::signed(10), 50, true), Error::<Test>::NotCandidate);
 		// Votes are stored
 		assert_eq!(<Votes<Test>>::get(30, 10), Some(Vote::Approve));
 		assert_eq!(<Votes<Test>>::get(40, 10), Some(Vote::Approve));
 		assert_eq!(<Votes<Test>>::get(50, 10), None);
-		run_to_block(8);
+		next_intake();
 		// Candidates become members after a period rotation
 		assert_eq!(members(), vec![10, 30, 40]);
 		// Votes are cleaned up
@@ -845,7 +916,7 @@ fn max_limits_work() {
 		// Last bid is smallest number + 99 (1099)
 		assert_eq!(bids[999], (1099, candidacy(1, 1099, BidKind::Deposit(25), 0, 0)));
 		// Rotate period
-		run_to_block(4);
+		next_intake();
 		// Max of 10 candidates
 		assert_eq!(candidates().len(), 10);
 		// Fill up membership, max 100, we will do just 95
@@ -855,7 +926,7 @@ fn max_limits_work() {
 		// Remember there was 1 original member, so 96 total
 		assert_eq!(members().len(), 96);
 		// Rotate period
-		run_to_block(8);
+		next_intake();
 		// Only of 4 candidates possible now
 		assert_eq!(candidates().len(), 4);
 		// Fill up members with suspended candidates from the first rotation
@@ -868,7 +939,7 @@ fn max_limits_work() {
 		}
 		assert_eq!(members().len(), 100);
 		// Can't add any more members
-		assert_noop!(Society::add_member(&98), Error::<Test, _>::MaxMembers);
+		assert_noop!(Society::add_member(&98), Error::<Test>::MaxMembers);
 		// However, a fringe scenario allows for in-progress candidates to increase the membership
 		// pool, but it has no real after-effects.
 		for i in members().iter() {
@@ -905,7 +976,7 @@ fn zero_bid_works() {
 		assert_ok!(Society::bid(Origin::signed(40), 0));
 
 		// Rotate period
-		run_to_block(4);
+		next_intake();
 		// Pot is 1000 after "PeriodSpend"
 		assert_eq!(Pot::<Test>::get(), 1000);
 		assert_eq!(Balances::free_balance(Society::account_id()), 10_000);
@@ -926,7 +997,7 @@ fn zero_bid_works() {
 		assert_ok!(Society::vote(Origin::signed(10), 30, true));
 		assert_ok!(Society::vote(Origin::signed(10), 50, true));
 		assert_ok!(Society::vote(Origin::signed(10), 60, true));
-		run_to_block(8);
+		next_intake();
 		// Candidates become members after a period rotation
 		assert_eq!(members(), vec![10, 30, 50, 60]);
 		// The zero bid is selected as head

From 8b997cd9c922639d432ea3630d6f8b624eb48709 Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@parity.io>
Date: Wed, 4 May 2022 16:12:59 +0100
Subject: [PATCH 08/43] More tests

---
 frame/society/src/lib.rs   |   4 +-
 frame/society/src/mock.rs  |   8 +-
 frame/society/src/tests.rs | 153 +++++++++++++++++++++----------------
 3 files changed, 94 insertions(+), 71 deletions(-)

diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index 6b99e31c8bb1b..c8fde907e8468 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -565,7 +565,7 @@ pub mod pallet {
 		/// Member is already vouching or banned from vouching again.
 		AlreadyVouching,
 		/// Member is not vouching.
-		NotVouching,
+		NotVouchingOnBidder,
 		/// Cannot remove the head of the chain.
 		Head,
 		/// Cannot remove the founder.
@@ -976,7 +976,7 @@ pub mod pallet {
 
 			let mut bids = Bids::<T, I>::get();
 			let pos = bids.iter().position(|bid| bid.kind.is_vouch(&voucher))
-				.ok_or(Error::<T, I>::NotVouching)?;
+				.ok_or(Error::<T, I>::NotVouchingOnBidder)?;
 			let bid = bids.remove(pos);
 			Self::clean_bid(&bid);
 
diff --git a/frame/society/src/mock.rs b/frame/society/src/mock.rs
index 19f08296baf8a..4243302efdf62 100644
--- a/frame/society/src/mock.rs
+++ b/frame/society/src/mock.rs
@@ -177,16 +177,16 @@ pub fn run_to_block(n: u64) {
 		Society::on_initialize(System::block_number());
 	}
 }
-/*
+
 /// Creates a bid struct using input parameters.
-pub fn create_bid<AccountId, Balance>(
-	value: Balance,
+pub fn bid<AccountId, Balance>(
 	who: AccountId,
 	kind: BidKind<AccountId, Balance>,
+	value: Balance,
 ) -> Bid<AccountId, Balance> {
 	Bid { who, kind, value }
 }
-*/
+
 /// Creates a candidate struct using input parameters.
 pub fn candidacy<AccountId, Balance>(
 	round: RoundIndex,
diff --git a/frame/society/src/tests.rs b/frame/society/src/tests.rs
index c3c6984851ec5..c5428f9d484a1 100644
--- a/frame/society/src/tests.rs
+++ b/frame/society/src/tests.rs
@@ -339,7 +339,7 @@ fn basic_new_member_reject_works() {
 		assert_eq!(members(), vec![10]);
 		// User is rejected.
 		assert_eq!(candidacies(), vec![]);
-		assert_eq!(Bids::<Test>::get(), vec![]);
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![]);
 	});
 }
 
@@ -507,9 +507,8 @@ fn suspended_candidate_rejected_works() {
 	});
 }
 
-/*
 #[test]
-fn vouch_works() {
+fn unpaid_vouch_works() {
 	EnvBuilder::new().execute(|| {
 		// 10 is the only member
 		assert_eq!(members(), vec![10]);
@@ -517,52 +516,74 @@ fn vouch_works() {
 		assert_noop!(Society::vouch(Origin::signed(1), 20, 1000, 100), Error::<Test>::NotMember);
 		// A member can though
 		assert_ok!(Society::vouch(Origin::signed(10), 20, 1000, 100));
-		assert_eq!(<Vouching<Test>>::get(10), Some(VouchingStatus::Vouching));
+		assert_eq!(Members::<Test>::get(10).unwrap().vouching, Some(VouchingStatus::Vouching));
 		// A member cannot vouch twice at the same time
 		assert_noop!(
 			Society::vouch(Origin::signed(10), 30, 100, 0),
 			Error::<Test>::AlreadyVouching
 		);
 		// Vouching creates the right kind of bid
-		assert_eq!(<Bids<Test>>::get(), vec![(20, candidacy(1, 1000, BidKind::Vouch(10,, 0, 0) 100))]);
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(20, BidKind::Vouch(10, 100), 1000)]);
 		// Vouched user can become candidate
 		next_intake();
-		assert_eq!(candidacies(), vec![(20, candidacy(1, 1000, BidKind::Vouch(10,, 0, 0) 100))]);
+		assert_eq!(candidacies(), vec![(20, candidacy(1, 1000, BidKind::Vouch(10, 100), 0, 0))]);
 		// Vote yes
 		assert_ok!(Society::vote(Origin::signed(10), 20, true));
 		// Vouched user can win
-		next_intake();
+		conclude_intake(true, None);
+		assert_eq!(members(), vec![10, 20]);
+		// Vouched user gets whatever remains after the voucher's reservation.
+		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(8, 900)].try_into().unwrap() });
+		// 10 is no longer vouching
+		assert_eq!(Members::<Test>::get(10).unwrap().vouching, None);
+	});
+}
+
+#[test]
+fn paid_vouch_works() {
+	EnvBuilder::new().execute(|| {
+		place_members([20]);
 		assert_eq!(members(), vec![10, 20]);
+
+		assert_ok!(Society::vouch(Origin::signed(20), 30, 1000, 100));
+		assert_eq!(Members::<Test>::get(20).unwrap().vouching, Some(VouchingStatus::Vouching));
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(30, BidKind::Vouch(20, 100), 1000)]);
+
+		next_intake();
+		assert_eq!(candidacies(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20, 100), 0, 0))]);
+		assert_ok!(Society::vote(Origin::signed(20), 30, true));
+		conclude_intake(true, None);
+
+		assert_eq!(members(), vec![10, 20, 30]);
 		// Voucher wins a portion of the payment
-		assert_eq!(Payouts::<Test>::get(10), PayoutRecord { paid: 0, payouts: vec![(9, 100)].try_into().unwrap() });
+		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(8, 100)].try_into().unwrap() });
 		// Vouched user wins the rest
-		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(9, 900)].try_into().unwrap() });
-		// 10 is no longer vouching
-		assert_eq!(<Vouching<Test>>::get(10), None);
+		assert_eq!(Payouts::<Test>::get(30), PayoutRecord { paid: 0, payouts: vec![(8, 900)].try_into().unwrap() });
+		// 20 is no longer vouching
+		assert_eq!(Members::<Test>::get(20).unwrap().vouching, None);
 	});
 }
 
 #[test]
 fn voucher_cannot_win_more_than_bid() {
 	EnvBuilder::new().execute(|| {
-		// 10 is the only member
-		assert_eq!(members(), vec![10]);
-		// 10 vouches, but asks for more than the bid
-		assert_ok!(Society::vouch(Origin::signed(10), 20, 100, 1000));
+		place_members([20]);
+		// 20 vouches, but asks for more than the bid
+		assert_ok!(Society::vouch(Origin::signed(20), 30, 100, 1000));
 		// Vouching creates the right kind of bid
-		assert_eq!(<Bids<Test>>::get(), vec![(20, candidacy(1, 100, BidKind::Vouch(10,, 0, 0) 1000))]);
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(30, BidKind::Vouch(20, 1000), 100)]);
 		// Vouched user can become candidate
 		next_intake();
-		assert_eq!(candidacies(), vec![(20, candidacy(1, 100, BidKind::Vouch(10,, 0, 0) 1000))]);
+		assert_eq!(candidacies(), vec![(30, candidacy(1, 100, BidKind::Vouch(20, 1000), 0, 0))]);
 		// Vote yes
-		assert_ok!(Society::vote(Origin::signed(10), 20, true));
+		assert_ok!(Society::vote(Origin::signed(20), 30, true));
 		// Vouched user can win
-		next_intake();
-		assert_eq!(members(), vec![10, 20]);
+		conclude_intake(true, None);
+		assert_eq!(members(), vec![10, 20, 30]);
 		// Voucher wins as much as the bid
-		assert_eq!(Payouts::<Test>::get(10), PayoutRecord { paid: 0, payouts: vec![(9, 100)].try_into().unwrap() });
+		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(8, 100)].try_into().unwrap() });
 		// Vouched user gets nothing
-		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![].try_into().unwrap() });
+		assert_eq!(Payouts::<Test>::get(30), PayoutRecord { paid: 0, payouts: vec![].try_into().unwrap() });
 	});
 }
 
@@ -574,35 +595,36 @@ fn unvouch_works() {
 		// 10 vouches for 20
 		assert_ok!(Society::vouch(Origin::signed(10), 20, 100, 0));
 		// 20 has a bid
-		assert_eq!(<Bids<Test>>::get(), vec![(20, candidacy(1, 100, BidKind::Vouch(10,, 0, 0) 0))]);
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(20, BidKind::Vouch(10, 0), 100)]);
 		// 10 is vouched
-		assert_eq!(<Vouching<Test>>::get(10), Some(VouchingStatus::Vouching));
-		// To unvouch, you must know the right bid position
-		assert_noop!(Society::unvouch(Origin::signed(10), 2), Error::<Test>::BadPosition);
-		// 10 can unvouch with the right position
-		assert_ok!(Society::unvouch(Origin::signed(10), 0));
+		assert_eq!(Members::<Test>::get(10).unwrap().vouching, Some(VouchingStatus::Vouching));
+		// 10 can unvouch
+		assert_ok!(Society::unvouch(Origin::signed(10)));
 		// 20 no longer has a bid
-		assert_eq!(<Bids<Test>>::get(), vec![]);
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![]);
 		// 10 is no longer vouching
-		assert_eq!(<Vouching<Test>>::get(10), None);
+		assert_eq!(Members::<Test>::get(10).unwrap().vouching, None);
 
 		// Cannot unvouch after they become candidate
 		assert_ok!(Society::vouch(Origin::signed(10), 20, 100, 0));
 		next_intake();
-		assert_eq!(candidacies(), vec![(20, candidacy(1, 100, BidKind::Vouch(10,, 0, 0) 0))]);
-		assert_noop!(Society::unvouch(Origin::signed(10), 0), Error::<Test>::BadPosition);
+		assert_eq!(candidacies(), vec![(20, candidacy(1, 100, BidKind::Vouch(10, 0), 0, 0))]);
+		assert_noop!(Society::unvouch(Origin::signed(10)), Error::<Test>::NotVouchingOnBidder);
+
 		// 10 is still vouching until candidate is approved or rejected
-		assert_eq!(<Vouching<Test>>::get(10), Some(VouchingStatus::Vouching));
-		next_intake();
-		// In this case candidate is denied and suspended
-		assert!(Society::suspended_candidate(&20).is_some());
-		assert_eq!(members(), vec![10]);
-		// User is stuck vouching until judgement origin resolves suspended candidate
-		assert_eq!(<Vouching<Test, _>>::get(10), Some(VouchingStatus::Vouching));
-		// Judge denies candidate
-		assert_ok!(Society::judge_suspended_candidate(Origin::signed(2), 20, Judgement::Reject));
-		// 10 is banned from vouching
-		assert_eq!(<Vouching<Test, _>>::get(10), Some(VouchingStatus::Banned));
+		assert_eq!(Members::<Test>::get(10).unwrap().vouching, Some(VouchingStatus::Vouching));
+		// Voucher inexplicably votes against their pick.
+		assert_ok!(Society::vote(Origin::signed(10), 20, false));
+		// But their pick doesn't resign (yet).
+		conclude_intake(false, None);
+		// Voting still happening and voucher cannot unvouch.
+		assert_eq!(candidacies(), vec![(20, candidacy(1, 100, BidKind::Vouch(10, 0), 0, 1))]);
+		assert_eq!(Members::<Test>::get(10).unwrap().vouching, Some(VouchingStatus::Vouching));
+
+		// Candidate gives in and resigns.
+		conclude_intake(true, None);
+		// Vouxher (10) is banned from vouching.
+		assert_eq!(Members::<Test>::get(10).unwrap().vouching, Some(VouchingStatus::Banned));
 		assert_eq!(members(), vec![10]);
 
 		// 10 cannot vouch again
@@ -611,10 +633,11 @@ fn unvouch_works() {
 			Error::<Test>::AlreadyVouching
 		);
 		// 10 cannot unvouch either, so they are banned forever.
-		assert_noop!(Society::unvouch(Origin::signed(10), 0), Error::<Test>::NotVouching);
+		assert_noop!(Society::unvouch(Origin::signed(10)), Error::<Test>::NotVouchingOnBidder);
 	});
 }
 
+/*
 #[test]
 fn unbid_vouch_works() {
 	EnvBuilder::new().execute(|| {
@@ -623,14 +646,14 @@ fn unbid_vouch_works() {
 		// 10 vouches for 20
 		assert_ok!(Society::vouch(Origin::signed(10), 20, 100, 0));
 		// 20 has a bid
-		assert_eq!(<Bids<Test>>::get(), vec![(20, candidacy(1, 100, BidKind::Vouch(10,, 0, 0) 0))]);
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(20, BidKind::Vouch(10, 0), 100)]);
 		// 10 is vouched
-		assert_eq!(<Vouching<Test>>::get(10), Some(VouchingStatus::Vouching));
+		assert_eq!(Members::<Test>::get(10).unwrap().vouching, Some(VouchingStatus::Vouching));
 		// 20 doesn't want to be a member and can unbid themselves.
 		assert_ok!(Society::unbid(Origin::signed(20)));
 		// Everything is cleaned up
-		assert_eq!(<Vouching<Test>>::get(10), None);
-		assert_eq!(<Bids<Test>>::get(), vec![]);
+		assert_eq!(Members::<Test>::get(10).unwrap().vouching, None);
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![]);
 	});
 }
 
@@ -821,19 +844,19 @@ fn vouching_handles_removed_member_with_bid() {
 		// Have that member vouch for a user
 		assert_ok!(Society::vouch(Origin::signed(20), 30, 1000, 100));
 		// That user is now a bid and the member is vouching
-		assert_eq!(<Bids<Test>>::get(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20,, 0, 0) 100))]);
-		assert_eq!(<Vouching<Test>>::get(20), Some(VouchingStatus::Vouching));
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(30, BidKind::Vouch(20, 100), 1000)]);
+		assert_eq!(Members::<Test>::get(20).unwrap().vouching, Some(VouchingStatus::Vouching));
 		// Suspend that member
 		Society::suspend_member(&20);
 		assert_eq!(SuspendedMembers::<Test>::contains_key(20), true);
 		// Nothing changes yet
-		assert_eq!(<Bids<Test>>::get(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20,, 0, 0) 100))]);
-		assert_eq!(<Vouching<Test>>::get(20), Some(VouchingStatus::Vouching));
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(30, BidKind::Vouch(20, 100), 1000)]);
+		assert_eq!(Members::<Test>::get(20).unwrap().vouching, Some(VouchingStatus::Vouching));
 		// Remove member
 		assert_ok!(Society::judge_suspended_member(Origin::signed(2), 20, false));
 		// Bid is removed, vouching status is removed
-		assert_eq!(<Bids<Test>>::get(), vec![]);
-		assert_eq!(<Vouching<Test>>::get(20), None);
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![]);
+		assert_eq!(Members::<Test>::get(20).unwrap().vouching, None);
 	});
 }
 
@@ -845,29 +868,29 @@ fn vouching_handles_removed_member_with_candidate() {
 		// Have that member vouch for a user
 		assert_ok!(Society::vouch(Origin::signed(20), 30, 1000, 100));
 		// That user is now a bid and the member is vouching
-		assert_eq!(<Bids<Test>>::get(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20,, 0, 0) 100))]);
-		assert_eq!(<Vouching<Test>>::get(20), Some(VouchingStatus::Vouching));
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(30, BidKind::Vouch(20, 100), 1000)]);
+		assert_eq!(Members::<Test>::get(20).unwrap().vouching, Some(VouchingStatus::Vouching));
 		// Make that bid a candidate
 		next_intake();
-		assert_eq!(candidacies(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20,, 0, 0) 100))]);
+		assert_eq!(candidacies(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20, 100), 0, 0))]);
 		// Suspend that member
 		Society::suspend_member(&20);
 		assert_eq!(SuspendedMembers::<Test>::contains_key(20), true);
 		// Nothing changes yet
-		assert_eq!(candidacies(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20,, 0, 0) 100))]);
-		assert_eq!(<Vouching<Test>>::get(20), Some(VouchingStatus::Vouching));
+		assert_eq!(candidacies(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20, 100), 0, 0))]);
+		assert_eq!(Members::<Test>::get(20).unwrap().vouching, Some(VouchingStatus::Vouching));
 		// Remove member
 		assert_ok!(Society::judge_suspended_member(Origin::signed(2), 20, false));
 		// Vouching status is removed, but candidate is still in the queue
-		assert_eq!(<Vouching<Test>>::get(20), None);
-		assert_eq!(candidacies(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20,, 0, 0) 100))]);
+		assert_eq!(Members::<Test>::get(20).unwrap().vouching, None);
+		assert_eq!(candidacies(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20, 100), 0, 0))]);
 		// Candidate wins
 		assert_ok!(Society::vote(Origin::signed(10), 30, true));
 		next_intake();
 		assert_eq!(members(), vec![10, 30]);
 		// Payout does not go to removed member
 		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![].try_into().unwrap() });
-		assert_eq!(Payouts::<Test>::get(30), PayoutRecord { paid: 0, payouts: vec![(9, 1000)].try_into().unwrap() });
+		assert_eq!(Payouts::<Test>::get(30), PayoutRecord { paid: 0, payouts: vec![(8, 1000)].try_into().unwrap() });
 	});
 }
 
@@ -908,7 +931,7 @@ fn max_limits_work() {
 			let _ = Balances::make_free_balance_be(&(i as u128), 1000);
 			assert_ok!(Society::bid(Origin::signed(i as u128), i));
 		}
-		let bids = <Bids<Test>>::get();
+		let bids = Bids::<Test>::get();
 		// Length is 1000
 		assert_eq!(bids.len(), 1000);
 		// First bid is smallest number (100)
@@ -990,7 +1013,7 @@ fn zero_bid_works() {
 			]
 		);
 		assert_eq!(
-			<Bids<Test>>::get(),
+			Bids::<Test>::get(),
 			vec![(20, candidacy(1, 0, BidKind::Deposit(25), 0, 0)), (40, candidacy(1, 0, BidKind::Deposit(25), 0, 0)),]
 		);
 		// A member votes for these candidates to join the society
@@ -1026,7 +1049,7 @@ fn bids_ordered_correctly() {
 			}
 		}
 
-		assert_eq!(<Bids<Test>>::get(), final_list);
+		assert_eq!(Bids::<Test>::get(), final_list);
 	});
 }
 */
\ No newline at end of file

From 3f9fdbd120e829ed4e5cd555dac42ad2c6ce2019 Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@parity.io>
Date: Wed, 4 May 2022 16:37:18 +0100
Subject: [PATCH 09/43] Test number 20

---
 frame/society/src/lib.rs   | 19 +++++++-------
 frame/society/src/tests.rs | 51 ++++++++++++++++++++++++--------------
 2 files changed, 42 insertions(+), 28 deletions(-)

diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index c8fde907e8468..0b045e9d7239c 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -1424,8 +1424,9 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		// End current defender rotation
 		if let Some((defender, skeptic, tally)) = Defending::<T, I>::get() {
 			if tally.more_rejections() {
-				// Member has failed the challenge
-				Self::suspend_member(&defender);
+				// Member has failed the challenge: Suspend them. This will fail if they are Head
+				// or Founder, in which case we ignore.
+				let _ = Self::suspend_member(&defender);
 			}
 
 			// Check defender skeptic voted and that their vote was with the majority.
@@ -1681,7 +1682,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		let params = Parameters::<T, I>::get().ok_or(Error::<T, I>::NotGroup)?;
 		if record.strikes >= params.max_strikes {
 			// Way too many strikes: suspend.
-			Self::suspend_member(who);
+			let _ = Self::suspend_member(who);
 		}
 		Ok(())
 	}
@@ -1740,13 +1741,11 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	/// If the member was vouching, then this will be reset. Any bidders that the member was
 	/// vouching for will be cancelled unless they are already selected as candidates (in which case
 	/// they will be able to stand).
-	fn suspend_member(who: &T::AccountId) {
-		if let Ok(record) = Self::remove_member(&who) {
-			SuspendedMembers::<T, I>::insert(who, record);
-			Self::deposit_event(Event::<T, I>::MemberSuspended { member: who.clone() });
-		} else {
-			debug_assert!(false, "Unable to remove member (is it the Head or Founder?)")
-		}
+	fn suspend_member(who: &T::AccountId) -> DispatchResult {
+		let record = Self::remove_member(&who)?;
+		SuspendedMembers::<T, I>::insert(who, record);
+		Self::deposit_event(Event::<T, I>::MemberSuspended { member: who.clone() });
+		Ok(())
 	}
 
 	/// Select a member at random, given the RNG `rng`.
diff --git a/frame/society/src/tests.rs b/frame/society/src/tests.rs
index c5428f9d484a1..494321d51fe06 100644
--- a/frame/society/src/tests.rs
+++ b/frame/society/src/tests.rs
@@ -420,7 +420,7 @@ fn suspended_member_life_cycle_works() {
 		assert_eq!(members(), vec![10, 20]);
 
 		// Let's suspend them again, directly
-		Society::suspend_member(&20);
+		assert_ok!(Society::suspend_member(&20));
 		assert!(SuspendedMembers::<Test>::contains_key(20));
 		// Suspension judgement origin does not forgive the suspended member
 		assert_ok!(Society::judge_suspended_member(Origin::signed(10), 20, false));
@@ -637,7 +637,6 @@ fn unvouch_works() {
 	});
 }
 
-/*
 #[test]
 fn unbid_vouch_works() {
 	EnvBuilder::new().execute(|| {
@@ -667,57 +666,73 @@ fn founder_and_head_cannot_be_removed() {
 		// 10 can still accumulate strikes
 		assert_ok!(Society::bid(Origin::signed(20), 0));
 		next_intake();
+		conclude_intake(false, None);
 		assert_eq!(Members::<Test>::get(10).unwrap().strikes, 1);
 		assert_ok!(Society::bid(Origin::signed(30), 0));
-		run_to_block(16);
+		next_intake();
+		conclude_intake(false, None);
 		assert_eq!(Members::<Test>::get(10).unwrap().strikes, 2);
 		// Awkwardly they can obtain more than MAX_STRIKES...
 		assert_ok!(Society::bid(Origin::signed(40), 0));
-		run_to_block(24);
+		next_intake();
+		conclude_intake(false, None);
 		assert_eq!(Members::<Test>::get(10).unwrap().strikes, 3);
 
 		// Replace the head
 		assert_ok!(Society::bid(Origin::signed(50), 0));
-		run_to_block(28);
+		next_intake();
 		assert_ok!(Society::vote(Origin::signed(10), 50, true));
-		assert_ok!(Society::defender_vote(Origin::signed(10), true)); // Keep defender around
-		run_to_block(32);
+		conclude_intake(false, None);
 		assert_eq!(members(), vec![10, 50]);
+		assert_eq!(Head::<Test>::get(), Some(10));
+		next_intake();
 		assert_eq!(Head::<Test>::get(), Some(50));
 		// Founder is unchanged
 		assert_eq!(Founder::<Test>::get(), Some(10));
 
 		// 50 can still accumulate strikes
 		assert_ok!(Society::bid(Origin::signed(60), 0));
-		run_to_block(40);
+		next_intake();
+		// Force 50 to be Skeptic so it gets a strike.
+		Skeptic::<Test>::put(50);
+		conclude_intake(false, None);
 		assert_eq!(Members::<Test>::get(50).unwrap().strikes, 1);
 		assert_ok!(Society::bid(Origin::signed(70), 0));
-		run_to_block(48);
+		next_intake();
+		// Force 50 to be Skeptic so it gets a strike.
+		Skeptic::<Test>::put(50);
+		conclude_intake(false, None);
 		assert_eq!(Members::<Test>::get(50).unwrap().strikes, 2);
 
 		// Replace the head
 		assert_ok!(Society::bid(Origin::signed(80), 0));
-		run_to_block(52);
+		next_intake();
 		assert_ok!(Society::vote(Origin::signed(10), 80, true));
 		assert_ok!(Society::vote(Origin::signed(50), 80, true));
-		assert_ok!(Society::defender_vote(Origin::signed(10), true)); // Keep defender around
-		run_to_block(56);
+		conclude_intake(false, None);
+		next_intake();
 		assert_eq!(members(), vec![10, 50, 80]);
 		assert_eq!(Head::<Test>::get(), Some(80));
 		assert_eq!(Founder::<Test>::get(), Some(10));
 
 		// 50 can now be suspended for strikes
 		assert_ok!(Society::bid(Origin::signed(90), 0));
-		run_to_block(60);
-		// The candidate is rejected, so voting approve will give a strike
-		assert_ok!(Society::vote(Origin::signed(50), 90, true));
-		run_to_block(64);
-		assert_eq!(Members::<Test>::get(50).unwrap().strikes, 0);
-		assert_eq!(SuspendedMembers::<Test>::contains_key(50), true);
+		next_intake();
+		// Force 50 to be Skeptic and get it a strike.
+		Skeptic::<Test>::put(50);
+		conclude_intake(false, None);
+		next_intake();
+		assert_eq!(SuspendedMembers::<Test>::get(50), Some(MemberRecord {
+			rank: 0,
+			strikes: 3,
+			vouching: None,
+			index: 1,
+		}));
 		assert_eq!(members(), vec![10, 80]);
 	});
 }
 
+/*
 #[test]
 fn challenges_work() {
 	EnvBuilder::new().execute(|| {

From 98f40601bc52bdf4e6eff047142d8ba7912ad248 Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@parity.io>
Date: Wed, 4 May 2022 17:51:45 +0100
Subject: [PATCH 10/43] Tests

---
 frame/society/src/lib.rs   |  14 ++-
 frame/society/src/mock.rs  |   6 +-
 frame/society/src/tests.rs | 227 ++++++++++++++++++++++---------------
 3 files changed, 152 insertions(+), 95 deletions(-)

diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index 0b045e9d7239c..bc7943708ec32 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -1421,9 +1421,12 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 
 	/// End the current challenge period and start a new one.
 	fn rotate_challenge(rng: &mut impl RngCore) {
+		let mut next_defender = None;
+
 		// End current defender rotation
 		if let Some((defender, skeptic, tally)) = Defending::<T, I>::get() {
-			if tally.more_rejections() {
+			// We require strictly more approvals, since the member should be voting for themselves.
+			if !tally.more_approvals() {
 				// Member has failed the challenge: Suspend them. This will fail if they are Head
 				// or Founder, in which case we ignore.
 				let _ = Self::suspend_member(&defender);
@@ -1436,8 +1439,13 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 				| (Some(Vote { approve: true, .. }), false, true)
 				| (Some(Vote { approve: false, .. }), true, false)
 				=> {
-					// Punish skeptic.
+					// Punish skeptic and challenge them next.
 					let _ = Self::strike_member(&skeptic);
+					let founder = Founder::<T, I>::get();
+					let head = Head::<T, I>::get();
+					if Some(&skeptic) != founder.as_ref() && Some(&skeptic) != head.as_ref() {
+						next_defender = Some(skeptic);
+					}
 				}
 				_ => {}
 			}
@@ -1451,7 +1459,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		// Avoid challenging if there's only two members since we never challenge the Head or
 		// the Founder.
 		if MemberCount::<T, I>::get() > 2 {
-			let defender = Self::pick_defendent(rng).expect("exited if members empty; qed");
+			let defender = next_defender.or_else(|| Self::pick_defendent(rng)).expect("exited if members empty; qed");
 			let skeptic = Self::pick_member_except(rng, &defender).expect("exited if members empty; qed");
 			Self::deposit_event(Event::<T, I>::Challenged { member: defender.clone() });
 			Defending::<T, I>::put((defender, skeptic, Tally::default()));
diff --git a/frame/society/src/mock.rs b/frame/society/src/mock.rs
index 4243302efdf62..7734f292593a1 100644
--- a/frame/society/src/mock.rs
+++ b/frame/society/src/mock.rs
@@ -155,7 +155,7 @@ impl EnvBuilder {
 		ext.execute_with(|| {
 			if self.founded {
 				let r = b"be cool".to_vec();
-				assert!(Society::found_society(Origin::signed(1), 10, 100, 10, 2, 25, r).is_ok());
+				assert!(Society::found_society(Origin::signed(1), 10, 10, 8, 2, 25, r).is_ok());
 			}
 			f()
 		})
@@ -164,6 +164,10 @@ impl EnvBuilder {
 		self.founded = f;
 		self
 	}
+	pub fn with_pot(mut self, p: u64) -> Self {
+		self.pot = p;
+		self
+	}
 }
 
 /// Run until a particular block.
diff --git a/frame/society/src/tests.rs b/frame/society/src/tests.rs
index 494321d51fe06..8f394092c39e2 100644
--- a/frame/society/src/tests.rs
+++ b/frame/society/src/tests.rs
@@ -24,6 +24,12 @@ use frame_support::{assert_noop, assert_ok};
 use sp_core::blake2_256;
 use sp_runtime::traits::BadOrigin;
 
+fn next_challenge() {
+	let challenge_period: u64 = <Test as Config>::ChallengePeriod::get();
+	let now = System::block_number();
+	run_to_block(now + challenge_period - now % challenge_period);
+}
+
 fn next_voting() {
 	if let Period::Voting { more, .. } = Society::period() {
 		run_to_block(System::block_number() + more);
@@ -732,65 +738,73 @@ fn founder_and_head_cannot_be_removed() {
 	});
 }
 
-/*
 #[test]
 fn challenges_work() {
 	EnvBuilder::new().execute(|| {
 		// Add some members
-		assert_ok!(Society::add_member(&20));
-		assert_ok!(Society::add_member(&30));
-		assert_ok!(Society::add_member(&40));
+		place_members([20, 30, 40]);
 		// Votes are empty
-		assert_eq!(<DefenderVotes<Test>>::get(10), None);
-		assert_eq!(<DefenderVotes<Test>>::get(20), None);
-		assert_eq!(<DefenderVotes<Test>>::get(30), None);
-		assert_eq!(<DefenderVotes<Test>>::get(40), None);
+		assert_eq!(DefenderVotes::<Test>::get(10), None);
+		assert_eq!(DefenderVotes::<Test>::get(20), None);
+		assert_eq!(DefenderVotes::<Test>::get(30), None);
+		assert_eq!(DefenderVotes::<Test>::get(40), None);
 		// Check starting point
 		assert_eq!(members(), vec![10, 20, 30, 40]);
-		assert_eq!(Society::defender(), None);
-		// 20 will be challenged during the challenge rotation
-		next_intake();
-		assert_eq!(Society::defender(), Some(30));
+		assert_eq!(Defending::<Test>::get(), None);
+
+		// 30 will be challenged during the challenge rotation
+		next_challenge();
+		assert_eq!(Defending::<Test>::get().unwrap().0, 30);
 		// They can always free vote for themselves
 		assert_ok!(Society::defender_vote(Origin::signed(30), true));
+
 		// If no one else votes, nothing happens
-		run_to_block(16);
+		next_challenge();
 		assert_eq!(members(), vec![10, 20, 30, 40]);
 		// New challenge period
-		assert_eq!(Society::defender(), Some(30));
-		// Non-member cannot challenge
+		assert_eq!(Defending::<Test>::get().unwrap().0, 30);
+		// Non-member cannot vote
 		assert_noop!(Society::defender_vote(Origin::signed(1), true), Error::<Test>::NotMember);
 		// 3 people say accept, 1 reject
 		assert_ok!(Society::defender_vote(Origin::signed(10), true));
 		assert_ok!(Society::defender_vote(Origin::signed(20), true));
 		assert_ok!(Society::defender_vote(Origin::signed(30), true));
 		assert_ok!(Society::defender_vote(Origin::signed(40), false));
-		run_to_block(24);
-		// 20 survives
+
+		next_challenge();
+		// 30 survives
 		assert_eq!(members(), vec![10, 20, 30, 40]);
 		// Votes are reset
-		assert_eq!(<DefenderVotes<Test>>::get(10), None);
-		assert_eq!(<DefenderVotes<Test>>::get(20), None);
-		assert_eq!(<DefenderVotes<Test>>::get(30), None);
-		assert_eq!(<DefenderVotes<Test>>::get(40), None);
+		assert_eq!(DefenderVotes::<Test>::get(10), None);
+		assert_eq!(DefenderVotes::<Test>::get(20), None);
+		assert_eq!(DefenderVotes::<Test>::get(30), None);
+		assert_eq!(DefenderVotes::<Test>::get(40), None);
+
 		// One more time
-		assert_eq!(Society::defender(), Some(30));
+		assert_eq!(Defending::<Test>::get().unwrap().0, 30);
 		// 2 people say accept, 2 reject
 		assert_ok!(Society::defender_vote(Origin::signed(10), true));
 		assert_ok!(Society::defender_vote(Origin::signed(20), true));
 		assert_ok!(Society::defender_vote(Origin::signed(30), false));
 		assert_ok!(Society::defender_vote(Origin::signed(40), false));
-		run_to_block(32);
-		// 20 is suspended
+		next_challenge();
+
+		// 30 is suspended
 		assert_eq!(members(), vec![10, 20, 40]);
-		assert_eq!(Society::suspended_member(30), true);
+		assert_eq!(SuspendedMembers::<Test>::get(30), Some(MemberRecord {
+			rank: 0,
+			strikes: 0,
+			vouching: None,
+			index: 2,
+		}));
+
 		// New defender is chosen
-		assert_eq!(Society::defender(), Some(20));
+		assert_eq!(Defending::<Test>::get().unwrap().0, 20);
 		// Votes are reset
-		assert_eq!(<DefenderVotes<Test>>::get(10), None);
-		assert_eq!(<DefenderVotes<Test>>::get(20), None);
-		assert_eq!(<DefenderVotes<Test>>::get(30), None);
-		assert_eq!(<DefenderVotes<Test>>::get(40), None);
+		assert_eq!(DefenderVotes::<Test>::get(10), None);
+		assert_eq!(DefenderVotes::<Test>::get(20), None);
+		assert_eq!(DefenderVotes::<Test>::get(30), None);
+		assert_eq!(DefenderVotes::<Test>::get(40), None);
 	});
 }
 
@@ -798,38 +812,38 @@ fn challenges_work() {
 fn bad_vote_slash_works() {
 	EnvBuilder::new().execute(|| {
 		// Add some members
-		assert_ok!(Society::add_member(&20));
-		assert_ok!(Society::add_member(&30));
-		assert_ok!(Society::add_member(&40));
+		place_members([20, 30, 40, 50]);
+		assert_eq!(members(), vec![10, 20, 30, 40, 50]);
 		// Create some payouts
-		Society::bump_payout(&10, 5, 100);
 		Society::bump_payout(&20, 5, 100);
 		Society::bump_payout(&30, 5, 100);
 		Society::bump_payout(&40, 5, 100);
+		Society::bump_payout(&50, 5, 100);
 		// Check starting point
-		assert_eq!(members(), vec![10, 20, 30, 40]);
-		assert_eq!(Payouts::<Test>::get(10), PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() });
 		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() });
 		assert_eq!(Payouts::<Test>::get(30), PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() });
 		assert_eq!(Payouts::<Test>::get(40), PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() });
+		assert_eq!(Payouts::<Test>::get(50), PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() });
 		// Create a new bid
-		assert_ok!(Society::bid(Origin::signed(50), 1000));
-		next_intake();
-		assert_ok!(Society::vote(Origin::signed(10), 50, false));
-		assert_ok!(Society::vote(Origin::signed(20), 50, true));
-		assert_ok!(Society::vote(Origin::signed(30), 50, false));
-		assert_ok!(Society::vote(Origin::signed(40), 50, false));
+		assert_ok!(Society::bid(Origin::signed(60), 1000));
 		next_intake();
+		// Force 20 to be the skeptic, and make it vote against the settled majority.
+		Skeptic::<Test>::put(20);
+		assert_ok!(Society::vote(Origin::signed(20), 60, true));
+		assert_ok!(Society::vote(Origin::signed(30), 60, false));
+		assert_ok!(Society::vote(Origin::signed(40), 60, false));
+		assert_ok!(Society::vote(Origin::signed(50), 60, false));
+		conclude_intake(false, None);
 		// Wrong voter gained a strike
-		assert_eq!(<Strikes<Test>>::get(10), 0);
-		assert_eq!(<Strikes<Test>>::get(20), 1);
-		assert_eq!(<Strikes<Test>>::get(30), 0);
-		assert_eq!(<Strikes<Test>>::get(40), 0);
+		assert_eq!(Members::<Test>::get(20).unwrap().strikes, 1);
+		assert_eq!(Members::<Test>::get(30).unwrap().strikes, 0);
+		assert_eq!(Members::<Test>::get(40).unwrap().strikes, 0);
+		assert_eq!(Members::<Test>::get(50).unwrap().strikes, 0);
 		// Their payout is slashed, a random person is rewarded
-		assert_eq!(Payouts::<Test>::get(10), PayoutRecord { paid: 0, payouts: vec![(5, 100), (9, 2)].try_into().unwrap() });
-		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(5, 98)].try_into().unwrap() });
+		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(5, 50)].try_into().unwrap() });
 		assert_eq!(Payouts::<Test>::get(30), PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() });
 		assert_eq!(Payouts::<Test>::get(40), PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() });
+		assert_eq!(Payouts::<Test>::get(50), PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() });
 	});
 }
 
@@ -843,7 +857,7 @@ fn user_cannot_bid_twice() {
 		assert_ok!(Society::vouch(Origin::signed(10), 30, 100, 100));
 		assert_noop!(Society::bid(Origin::signed(30), 100), Error::<Test>::AlreadyBid);
 		// Cannot vouch when already bid
-		assert_ok!(Society::add_member(&50));
+		place_members([50]);
 		assert_noop!(
 			Society::vouch(Origin::signed(50), 20, 100, 100),
 			Error::<Test>::AlreadyBid
@@ -855,23 +869,19 @@ fn user_cannot_bid_twice() {
 fn vouching_handles_removed_member_with_bid() {
 	EnvBuilder::new().execute(|| {
 		// Add a member
-		assert_ok!(Society::add_member(&20));
+		place_members([20]);
 		// Have that member vouch for a user
 		assert_ok!(Society::vouch(Origin::signed(20), 30, 1000, 100));
 		// That user is now a bid and the member is vouching
 		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(30, BidKind::Vouch(20, 100), 1000)]);
 		assert_eq!(Members::<Test>::get(20).unwrap().vouching, Some(VouchingStatus::Vouching));
 		// Suspend that member
-		Society::suspend_member(&20);
-		assert_eq!(SuspendedMembers::<Test>::contains_key(20), true);
-		// Nothing changes yet
-		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(30, BidKind::Vouch(20, 100), 1000)]);
-		assert_eq!(Members::<Test>::get(20).unwrap().vouching, Some(VouchingStatus::Vouching));
-		// Remove member
-		assert_ok!(Society::judge_suspended_member(Origin::signed(2), 20, false));
+		assert_ok!(Society::suspend_member(&20));
 		// Bid is removed, vouching status is removed
+		let r = MemberRecord { rank: 0, strikes: 0, vouching: None, index: 1 };
+		assert_eq!(SuspendedMembers::<Test>::get(20), Some(r));
 		assert_eq!(Bids::<Test>::get().into_inner(), vec![]);
-		assert_eq!(Members::<Test>::get(20).unwrap().vouching, None);
+		assert_eq!(Members::<Test>::get(20), None);
 	});
 }
 
@@ -879,29 +889,26 @@ fn vouching_handles_removed_member_with_bid() {
 fn vouching_handles_removed_member_with_candidate() {
 	EnvBuilder::new().execute(|| {
 		// Add a member
-		assert_ok!(Society::add_member(&20));
+		place_members([20]);
 		// Have that member vouch for a user
 		assert_ok!(Society::vouch(Origin::signed(20), 30, 1000, 100));
 		// That user is now a bid and the member is vouching
 		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(30, BidKind::Vouch(20, 100), 1000)]);
 		assert_eq!(Members::<Test>::get(20).unwrap().vouching, Some(VouchingStatus::Vouching));
+
 		// Make that bid a candidate
 		next_intake();
 		assert_eq!(candidacies(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20, 100), 0, 0))]);
 		// Suspend that member
-		Society::suspend_member(&20);
+		assert_ok!(Society::suspend_member(&20));
 		assert_eq!(SuspendedMembers::<Test>::contains_key(20), true);
-		// Nothing changes yet
-		assert_eq!(candidacies(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20, 100), 0, 0))]);
-		assert_eq!(Members::<Test>::get(20).unwrap().vouching, Some(VouchingStatus::Vouching));
-		// Remove member
-		assert_ok!(Society::judge_suspended_member(Origin::signed(2), 20, false));
-		// Vouching status is removed, but candidate is still in the queue
-		assert_eq!(Members::<Test>::get(20).unwrap().vouching, None);
+
+		// Nothing changes yet in the candidacy, though the member now forgets.
 		assert_eq!(candidacies(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20, 100), 0, 0))]);
+
 		// Candidate wins
 		assert_ok!(Society::vote(Origin::signed(10), 30, true));
-		next_intake();
+		conclude_intake(false, None);
 		assert_eq!(members(), vec![10, 30]);
 		// Payout does not go to removed member
 		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![].try_into().unwrap() });
@@ -912,6 +919,7 @@ fn vouching_handles_removed_member_with_candidate() {
 #[test]
 fn votes_are_working() {
 	EnvBuilder::new().execute(|| {
+		place_members([20]);
 		// Users make bids of various amounts
 		assert_ok!(Society::bid(Origin::signed(50), 500));
 		assert_ok!(Society::bid(Origin::signed(40), 400));
@@ -920,53 +928,90 @@ fn votes_are_working() {
 		next_intake();
 		// A member votes for these candidates to join the society
 		assert_ok!(Society::vote(Origin::signed(10), 30, true));
+		assert_ok!(Society::vote(Origin::signed(20), 30, true));
 		assert_ok!(Society::vote(Origin::signed(10), 40, true));
 		// You cannot vote for a non-candidate
 		assert_noop!(Society::vote(Origin::signed(10), 50, true), Error::<Test>::NotCandidate);
 		// Votes are stored
-		assert_eq!(<Votes<Test>>::get(30, 10), Some(Vote::Approve));
-		assert_eq!(<Votes<Test>>::get(40, 10), Some(Vote::Approve));
+		assert_eq!(<Votes<Test>>::get(30, 10), Some(Vote { approve: true, weight: 4 }));
+		assert_eq!(<Votes<Test>>::get(30, 20), Some(Vote { approve: true, weight: 1 }));
+		assert_eq!(<Votes<Test>>::get(40, 10), Some(Vote { approve: true, weight: 4 }));
 		assert_eq!(<Votes<Test>>::get(50, 10), None);
-		next_intake();
+		conclude_intake(false, None);
 		// Candidates become members after a period rotation
-		assert_eq!(members(), vec![10, 30, 40]);
+		assert_eq!(members(), vec![10, 20, 30, 40]);
 		// Votes are cleaned up
 		assert_eq!(<Votes<Test>>::get(30, 10), None);
+		assert_eq!(<Votes<Test>>::get(30, 20), None);
 		assert_eq!(<Votes<Test>>::get(40, 10), None);
 	});
 }
 
 #[test]
-fn max_limits_work() {
-	EnvBuilder::new().with_pot(100000).execute(|| {
+fn max_bids_work() {
+	EnvBuilder::new().execute(|| {
 		// Max bids is 1000, when extra bids come in, it pops the larger ones off the stack.
 		// Try to put 1010 users into the bid pool
-		for i in (100..1110).rev() {
-			// Give them some funds
-			let _ = Balances::make_free_balance_be(&(i as u128), 1000);
-			assert_ok!(Society::bid(Origin::signed(i as u128), i));
+		for i in (0..=10).rev() {
+			// Give them some funds and bid
+			let _ = Balances::make_free_balance_be(&((i + 100) as u128), 1000);
+			assert_ok!(Society::bid(Origin::signed((i + 100) as u128), i));
 		}
 		let bids = Bids::<Test>::get();
 		// Length is 1000
-		assert_eq!(bids.len(), 1000);
+		assert_eq!(bids.len(), 10);
 		// First bid is smallest number (100)
-		assert_eq!(bids[0], (100, candidacy(1, 100, BidKind::Deposit(25), 0, 0)));
+		assert_eq!(bids[0], bid(100, BidKind::Deposit(25), 0));
 		// Last bid is smallest number + 99 (1099)
-		assert_eq!(bids[999], (1099, candidacy(1, 1099, BidKind::Deposit(25), 0, 0)));
-		// Rotate period
+		assert_eq!(bids[9], bid(109, BidKind::Deposit(25), 9));
+	});
+}
+
+#[test]
+fn candidates_are_limited_by_membership_size() {
+	EnvBuilder::new().execute(|| {
+		// Fill up some membership
+		place_members([1, 2, 3, 4, 5, 6, 7, 8]);
+		// One place left from 10
+		assert_eq!(members().len(), 9);
+
+		assert_ok!(Society::bid(Origin::signed(20), 0));
+		assert_ok!(Society::bid(Origin::signed(30), 1));
 		next_intake();
-		// Max of 10 candidates
-		assert_eq!(candidates().len(), 10);
-		// Fill up membership, max 100, we will do just 95
-		for i in 2000..2095 {
-			assert_ok!(Society::add_member(&(i as u128)));
+		assert_eq!(candidates().len(), 1);
+	});
+}
+
+#[test]
+fn candidates_are_limited_by_maximum() {
+	EnvBuilder::new().execute(|| {
+		// Nine places left from 10
+		assert_eq!(members().len(), 1);
+
+		// Nine bids
+		for i in (1..=9).rev() {
+			// Give them some funds and bid
+			let _ = Balances::make_free_balance_be(&((i + 100) as u128), 1000);
+			assert_ok!(Society::bid(Origin::signed((i + 100) as u128), i));
 		}
-		// Remember there was 1 original member, so 96 total
-		assert_eq!(members().len(), 96);
-		// Rotate period
 		next_intake();
+
+		// Still only 8 candidates.
+		assert_eq!(candidates().len(), 8);
+	});
+}
+
+/*
+#[test]
+fn candidates_are_limited_by_maximum() {
+	EnvBuilder::new().execute(|| {
+		for i in 
+		assert_ok!(Society::bid(Origin::signed(20), 0));
+		assert_ok!(Society::bid(Origin::signed(30), 1));
+
+		// Rotate period
+		conclude_intake();
 		// Only of 4 candidates possible now
-		assert_eq!(candidates().len(), 4);
 		// Fill up members with suspended candidates from the first rotation
 		for i in 100..104 {
 			assert_ok!(Society::judge_suspended_candidate(

From 3f6ba7406fa644da722db9331b7ec8a2bf8d8372 Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@parity.io>
Date: Wed, 4 May 2022 19:16:51 +0100
Subject: [PATCH 11/43] 30 tests

---
 frame/society/src/lib.rs   |  12 +++--
 frame/society/src/mock.rs  |  84 ++++++++++++++++++++++++++++-
 frame/society/src/tests.rs | 107 +++++++++----------------------------
 3 files changed, 117 insertions(+), 86 deletions(-)

diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index bc7943708ec32..4962df7d8f1f2 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -1658,16 +1658,22 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		mut candidacy: Candidacy<T::AccountId, BalanceOf<T, I>>,
 		rank: Rank,
 	) -> DispatchResult {
-		Self::check_skeptic(&candidate, &mut candidacy);
 		Self::add_new_member(&candidate, rank)?;
+		Self::check_skeptic(&candidate, &mut candidacy);
+		
 		let next_head = NextHead::<T, I>::get()
-			.filter(|old| old.round > candidacy.round
+			.filter(|old| {
+				old.round > candidacy.round
 				|| old.round == candidacy.round && old.bid < candidacy.bid
-			).unwrap_or_else(|| IntakeRecord { who: candidate.clone(), bid: candidacy.bid, round: candidacy.round });
+			}).unwrap_or_else(||
+				IntakeRecord { who: candidate.clone(), bid: candidacy.bid, round: candidacy.round }
+			);
 		NextHead::<T, I>::put(next_head);
+
 		let now = <frame_system::Pallet<T>>::block_number();
 		let maturity = now + Self::lock_duration(MemberCount::<T, I>::get());
 		Self::reward_bidder(&candidate, candidacy.bid, candidacy.kind, maturity);
+
 		Votes::<T, I>::remove_prefix(&candidate, None);
 		Candidates::<T, I>::remove(&candidate);
 		Ok(())
diff --git a/frame/society/src/mock.rs b/frame/society/src/mock.rs
index 7734f292593a1..57af930114bb4 100644
--- a/frame/society/src/mock.rs
+++ b/frame/society/src/mock.rs
@@ -21,7 +21,7 @@ use super::*;
 use crate as pallet_society;
 
 use frame_support::{
-	ord_parameter_types, parameter_types,
+	assert_noop, assert_ok, ord_parameter_types, parameter_types,
 	traits::{ConstU32, ConstU64},
 };
 use frame_support_test::TestRandomness;
@@ -201,3 +201,85 @@ pub fn candidacy<AccountId, Balance>(
 ) -> Candidacy<AccountId, Balance> {
 	Candidacy { round, kind, bid, tally: Tally { approvals, rejections }, skeptic_struck: false }
 }
+
+pub fn next_challenge() {
+	let challenge_period: u64 = <Test as Config>::ChallengePeriod::get();
+	let now = System::block_number();
+	run_to_block(now + challenge_period - now % challenge_period);
+}
+
+pub fn next_voting() {
+	if let Period::Voting { more, .. } = Society::period() {
+		run_to_block(System::block_number() + more);
+	}
+}
+
+pub fn conclude_intake(allow_resignation: bool, judge_intake: Option<bool>) {
+	next_voting();
+	let round = RoundCount::<Test>::get();
+	for (who, candidacy) in Candidates::<Test>::iter() {
+		if candidacy.tally.clear_approval() {
+			assert_ok!(Society::claim_membership(Origin::signed(who)));
+			assert_noop!(Society::claim_membership(Origin::signed(who)), Error::<Test>::NotCandidate);
+			continue
+		}
+		if candidacy.tally.clear_rejection() && allow_resignation {
+			assert_noop!(Society::claim_membership(Origin::signed(who)), Error::<Test>::NotApproved);
+			assert_ok!(Society::resign_candidacy(Origin::signed(who)));
+			continue
+		}
+		if let (Some(founder), Some(approve)) = (Founder::<Test>::get(), judge_intake) {
+			if !candidacy.tally.clear_approval() && !approve {
+				// can be rejected by founder
+				assert_ok!(Society::kick_candidate(Origin::signed(founder), who));
+				continue
+			}
+			if !candidacy.tally.clear_rejection() && approve {
+				// can be rejected by founder
+				assert_ok!(Society::bestow_membership(Origin::signed(founder), who));
+				continue
+			}
+		}
+		if candidacy.tally.clear_rejection() && round > candidacy.round + 1 {
+			assert_noop!(Society::claim_membership(Origin::signed(who)), Error::<Test>::NotApproved);
+			assert_ok!(Society::drop_candidate(Origin::signed(0), who));
+			assert_noop!(Society::drop_candidate(Origin::signed(0), who), Error::<Test>::NotCandidate);
+			continue
+		}
+		if !candidacy.skeptic_struck {
+			assert_ok!(Society::punish_skeptic(Origin::signed(who)));
+		}
+	}
+}
+
+pub fn next_intake() {
+	let claim_period: u64 = <Test as Config>::ClaimPeriod::get();
+	match Society::period() {
+		Period::Voting { more, .. } => run_to_block(System::block_number() + more + claim_period),
+		Period::Claim { more, .. } => run_to_block(System::block_number() + more),
+	}
+}
+
+pub fn place_members(members: impl AsRef<[u128]>) {
+	for who in members.as_ref() {
+		assert_ok!(Society::insert_member(who, 0));
+	}
+}
+
+pub fn members() -> Vec<u128> {
+	let mut r = Members::<Test>::iter_keys().collect::<Vec<_>>();
+	r.sort();
+	r
+}
+
+pub fn candidacies() -> Vec<(u128, Candidacy<u128, u64>)> {
+	let mut r = Candidates::<Test>::iter().collect::<Vec<_>>();
+	r.sort_by_key(|x| x.0);
+	r
+}
+
+pub fn candidates() -> Vec<u128> {
+	let mut r = Candidates::<Test>::iter_keys().collect::<Vec<_>>();
+	r.sort();
+	r
+}
diff --git a/frame/society/src/tests.rs b/frame/society/src/tests.rs
index 8f394092c39e2..528b737203a67 100644
--- a/frame/society/src/tests.rs
+++ b/frame/society/src/tests.rs
@@ -24,88 +24,6 @@ use frame_support::{assert_noop, assert_ok};
 use sp_core::blake2_256;
 use sp_runtime::traits::BadOrigin;
 
-fn next_challenge() {
-	let challenge_period: u64 = <Test as Config>::ChallengePeriod::get();
-	let now = System::block_number();
-	run_to_block(now + challenge_period - now % challenge_period);
-}
-
-fn next_voting() {
-	if let Period::Voting { more, .. } = Society::period() {
-		run_to_block(System::block_number() + more);
-	}
-}
-
-fn conclude_intake(allow_resignation: bool, judge_intake: Option<bool>) {
-	next_voting();
-	let round = RoundCount::<Test>::get();
-	for (who, candidacy) in Candidates::<Test>::iter() {
-		if candidacy.tally.clear_approval() {
-			assert_ok!(Society::claim_membership(Origin::signed(who)));
-			assert_noop!(Society::claim_membership(Origin::signed(who)), Error::<Test>::NotCandidate);
-			continue
-		}
-		if candidacy.tally.clear_rejection() && allow_resignation {
-			assert_noop!(Society::claim_membership(Origin::signed(who)), Error::<Test>::NotApproved);
-			assert_ok!(Society::resign_candidacy(Origin::signed(who)));
-			continue
-		}
-		if let (Some(founder), Some(approve)) = (Founder::<Test>::get(), judge_intake) {
-			if !candidacy.tally.clear_approval() && !approve {
-				// can be rejected by founder
-				assert_ok!(Society::kick_candidate(Origin::signed(founder), who));
-				continue
-			}
-			if !candidacy.tally.clear_rejection() && approve {
-				// can be rejected by founder
-				assert_ok!(Society::bestow_membership(Origin::signed(founder), who));
-				continue
-			}
-		}
-		if candidacy.tally.clear_rejection() && round > candidacy.round + 1 {
-			assert_noop!(Society::claim_membership(Origin::signed(who)), Error::<Test>::NotApproved);
-			assert_ok!(Society::drop_candidate(Origin::signed(0), who));
-			assert_noop!(Society::drop_candidate(Origin::signed(0), who), Error::<Test>::NotCandidate);
-			continue
-		}
-		if !candidacy.skeptic_struck {
-			assert_ok!(Society::punish_skeptic(Origin::signed(who)));
-		}
-	}
-}
-
-fn next_intake() {
-	let claim_period: u64 = <Test as Config>::ClaimPeriod::get();
-	match Society::period() {
-		Period::Voting { more, .. } => run_to_block(System::block_number() + more + claim_period),
-		Period::Claim { more, .. } => run_to_block(System::block_number() + more),
-	}
-}
-
-fn place_members(members: impl AsRef<[u128]>) {
-	for who in members.as_ref() {
-		assert_ok!(Society::insert_member(who, 0));
-	}
-}
-
-fn members() -> Vec<u128> {
-	let mut r = Members::<Test>::iter_keys().collect::<Vec<_>>();
-	r.sort();
-	r
-}
-
-fn candidacies() -> Vec<(u128, Candidacy<u128, u64>)> {
-	let mut r = Candidates::<Test>::iter().collect::<Vec<_>>();
-	r.sort_by_key(|x| x.0);
-	r
-}
-
-fn candidates() -> Vec<u128> {
-	let mut r = Candidates::<Test>::iter_keys().collect::<Vec<_>>();
-	r.sort();
-	r
-}
-
 #[test]
 fn founding_works() {
 	EnvBuilder::new().founded(false).execute(|| {
@@ -1001,6 +919,31 @@ fn candidates_are_limited_by_maximum() {
 	});
 }
 
+#[test]
+fn too_many_candidates_cannot_overflow_membership() {
+	EnvBuilder::new().execute(|| {
+		// One place left
+		place_members([1, 2, 3, 4, 5, 6, 7, 8]);
+		assert_ok!(Society::bid(Origin::signed(20), 0));
+		assert_ok!(Society::bid(Origin::signed(30), 1));
+		next_intake();
+		// Candidate says a candidate.
+		next_intake();
+		// Another candidate taken.
+		// Both approved.
+		assert_ok!(Society::vote(Origin::signed(10), 20, true));
+		assert_ok!(Society::vote(Origin::signed(10), 30, true));
+		next_voting();
+		assert_ok!(Society::claim_membership(Origin::signed(20)));
+		assert_noop!(Society::claim_membership(Origin::signed(30)), Error::<Test>::MaxMembers);
+
+		// Maximum members.
+		assert_eq!(members().len(), 10);
+		// Still 1 candidate.
+		assert_eq!(candidates().len(), 1);
+	});
+}
+
 /*
 #[test]
 fn candidates_are_limited_by_maximum() {

From 89c4bf66ad281301c0cc4647081519dada63d419 Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@parity.io>
Date: Thu, 5 May 2022 11:36:53 +0100
Subject: [PATCH 12/43] Another test]

---
 frame/society/src/tests.rs | 58 ++++++++------------------------------
 1 file changed, 11 insertions(+), 47 deletions(-)

diff --git a/frame/society/src/tests.rs b/frame/society/src/tests.rs
index 528b737203a67..8de73e0ecb4ab 100644
--- a/frame/society/src/tests.rs
+++ b/frame/society/src/tests.rs
@@ -941,50 +941,10 @@ fn too_many_candidates_cannot_overflow_membership() {
 		assert_eq!(members().len(), 10);
 		// Still 1 candidate.
 		assert_eq!(candidates().len(), 1);
-	});
-}
-
-/*
-#[test]
-fn candidates_are_limited_by_maximum() {
-	EnvBuilder::new().execute(|| {
-		for i in 
-		assert_ok!(Society::bid(Origin::signed(20), 0));
-		assert_ok!(Society::bid(Origin::signed(30), 1));
 
-		// Rotate period
-		conclude_intake();
-		// Only of 4 candidates possible now
-		// Fill up members with suspended candidates from the first rotation
-		for i in 100..104 {
-			assert_ok!(Society::judge_suspended_candidate(
-				Origin::signed(2),
-				i,
-				Judgement::Approve
-			));
-		}
-		assert_eq!(members().len(), 100);
-		// Can't add any more members
-		assert_noop!(Society::add_member(&98), Error::<Test>::MaxMembers);
-		// However, a fringe scenario allows for in-progress candidates to increase the membership
-		// pool, but it has no real after-effects.
-		for i in members().iter() {
-			assert_ok!(Society::vote(Origin::signed(*i), 110, true));
-			assert_ok!(Society::vote(Origin::signed(*i), 111, true));
-			assert_ok!(Society::vote(Origin::signed(*i), 112, true));
-		}
-		// Rotate period
-		run_to_block(12);
-		// Members length is over 100, no problem...
-		assert_eq!(members().len(), 103);
-		// No candidates because full
-		assert_eq!(candidates().len(), 0);
-		// Increase member limit
-		assert_ok!(Society::set_max_members(Origin::root(), 200));
-		// Rotate period
-		run_to_block(16);
-		// Candidates are back!
-		assert_eq!(candidates().len(), 10);
+		// Increase max-members and the candidate can get in.
+		assert_ok!(Society::set_parameters(Origin::signed(10), 11, 8, 3, 25));
+		assert_ok!(Society::claim_membership(Origin::signed(30)));
 	});
 }
 
@@ -1008,7 +968,7 @@ fn zero_bid_works() {
 		assert_eq!(Balances::free_balance(Society::account_id()), 10_000);
 		// Choose smallest bidding users whose total is less than pot, with only one zero bid.
 		assert_eq!(
-			candidates(),
+			candidacies(),
 			vec![
 				(30, candidacy(1, 0, BidKind::Deposit(25), 0, 0)),
 				(50, candidacy(1, 300, BidKind::Deposit(25), 0, 0)),
@@ -1017,20 +977,24 @@ fn zero_bid_works() {
 		);
 		assert_eq!(
 			Bids::<Test>::get(),
-			vec![(20, candidacy(1, 0, BidKind::Deposit(25), 0, 0)), (40, candidacy(1, 0, BidKind::Deposit(25), 0, 0)),]
+			vec![
+				bid(20, BidKind::Deposit(25), 0),
+				bid(40, BidKind::Deposit(25), 0),
+			],
 		);
 		// A member votes for these candidates to join the society
 		assert_ok!(Society::vote(Origin::signed(10), 30, true));
 		assert_ok!(Society::vote(Origin::signed(10), 50, true));
 		assert_ok!(Society::vote(Origin::signed(10), 60, true));
-		next_intake();
+		conclude_intake(false, None);
 		// Candidates become members after a period rotation
 		assert_eq!(members(), vec![10, 30, 50, 60]);
+		next_intake();
 		// The zero bid is selected as head
 		assert_eq!(Head::<Test>::get(), Some(30));
 	});
 }
-
+/*
 #[test]
 fn bids_ordered_correctly() {
 	// This tests that bids with the same value are placed in the list ordered

From db636beafac63df4d19261d08b43cb8e3e79e119 Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@parity.io>
Date: Thu, 5 May 2022 12:15:35 +0100
Subject: [PATCH 13/43] All tests enabled

---
 frame/society/src/lib.rs   |  4 ++--
 frame/society/src/mock.rs  |  4 ----
 frame/society/src/tests.rs | 13 +++++++------
 3 files changed, 9 insertions(+), 12 deletions(-)

diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index 4962df7d8f1f2..b44f020917cb5 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -871,9 +871,9 @@ pub mod pallet {
 
 			let params = Parameters::<T, I>::get().ok_or(Error::<T, I>::NotGroup)?;
 			let deposit = params.candidate_deposit;
-			Self::insert_bid(&mut bids, &who, value.clone(), BidKind::Deposit(deposit));
-
+			// NOTE: Reserve must happen before `insert_bid` since that could end up unreserving.
 			T::Currency::reserve(&who, deposit)?;
+			Self::insert_bid(&mut bids, &who, value.clone(), BidKind::Deposit(deposit));
 
 			Bids::<T, I>::put(bids);
 			Self::deposit_event(Event::<T, I>::Bid { candidate_id: who, offer: value });
diff --git a/frame/society/src/mock.rs b/frame/society/src/mock.rs
index 57af930114bb4..0d756718ea764 100644
--- a/frame/society/src/mock.rs
+++ b/frame/society/src/mock.rs
@@ -164,10 +164,6 @@ impl EnvBuilder {
 		self.founded = f;
 		self
 	}
-	pub fn with_pot(mut self, p: u64) -> Self {
-		self.pot = p;
-		self
-	}
 }
 
 /// Run until a particular block.
diff --git a/frame/society/src/tests.rs b/frame/society/src/tests.rs
index 8de73e0ecb4ab..5519d5d14284d 100644
--- a/frame/society/src/tests.rs
+++ b/frame/society/src/tests.rs
@@ -994,7 +994,7 @@ fn zero_bid_works() {
 		assert_eq!(Head::<Test>::get(), Some(30));
 	});
 }
-/*
+
 #[test]
 fn bids_ordered_correctly() {
 	// This tests that bids with the same value are placed in the list ordered
@@ -1003,8 +1003,9 @@ fn bids_ordered_correctly() {
 		for i in 0..5 {
 			for j in 0..5 {
 				// Give them some funds
-				let _ = Balances::make_free_balance_be(&(100 + (i * 5 + j) as u128), 1000);
-				assert_ok!(Society::bid(Origin::signed(100 + (i * 5 + j) as u128), j));
+				let who = 100 + (i * 5 + j) as u128;
+				let _ = Balances::make_free_balance_be(&who, 1000);
+				assert_ok!(Society::bid(Origin::signed(who), j));
 			}
 		}
 
@@ -1012,11 +1013,11 @@ fn bids_ordered_correctly() {
 
 		for j in 0..5 {
 			for i in 0..5 {
-				final_list.push((100 +candidacy(j1, ,  (i * 5 + j), 0, 0) as u128, BidKind::Deposit(25)));
+				final_list.push(bid(100 + (i * 5 + j) as u128, BidKind::Deposit(25), j));
 			}
 		}
-
+		let max_bids: u32 = <Test as Config>::MaxBids::get();
+		final_list.truncate(max_bids as usize);
 		assert_eq!(Bids::<Test>::get(), final_list);
 	});
 }
-*/
\ No newline at end of file

From d6abcb98bbb62edcc1110f1272c85b1e7d5abde8 Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@parity.io>
Date: Thu, 5 May 2022 18:46:49 +0100
Subject: [PATCH 14/43] Minor stuff

---
 Cargo.lock                |   2 +
 frame/society/Cargo.toml  |   2 +
 frame/society/src/lib.rs  | 132 ++++++++++++++++++--------------------
 frame/society/src/mock.rs |   4 +-
 4 files changed, 71 insertions(+), 69 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 7a5ef8e09ae7b..654c971f346f0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6559,10 +6559,12 @@ dependencies = [
  "frame-support",
  "frame-support-test",
  "frame-system",
+ "hex-literal",
  "pallet-balances",
  "parity-scale-codec",
  "rand_chacha 0.2.2",
  "scale-info",
+ "sp-arithmetic",
  "sp-core",
  "sp-io",
  "sp-runtime",
diff --git a/frame/society/Cargo.toml b/frame/society/Cargo.toml
index 1fd9693d0d00f..4f24d026c4234 100644
--- a/frame/society/Cargo.toml
+++ b/frame/society/Cargo.toml
@@ -17,9 +17,11 @@ codec = { package = "parity-scale-codec", version = "3.0.0", default-features =
 scale-info = { version = "2.0.1", default-features = false, features = ["derive"] }
 sp-runtime = { version = "6.0.0", default-features = false, path = "../../primitives/runtime" }
 sp-std = { version = "4.0.0", default-features = false, path = "../../primitives/std" }
+sp-arithmetic = { version = "5.0.0", default-features = false, path = "../../primitives/arithmetic" }
 frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
 frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
 rand_chacha = { version = "0.2", default-features = false }
+hex-literal = "0.3.4"
 
 [dev-dependencies]
 sp-core = { version = "6.0.0", path = "../../primitives/core" }
diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index b44f020917cb5..48ed6da71ac70 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -241,9 +241,6 @@
 //! * `set_max_membership` - The ROOT origin can update the maximum member count for the society.
 //! The max membership count must be greater than 1.
 
-// TODO: Sort out all the `limit: None` stuff for remove prefix.
-// TODO: Membership subsets: ranks and badges.
-
 // Ensure we're `no_std` when compiling for Wasm.
 #![cfg_attr(not(feature = "std"), no_std)]
 
@@ -253,6 +250,8 @@ mod mock;
 #[cfg(test)]
 mod tests;
 
+pub mod migrations;
+
 use frame_support::{
 	pallet_prelude::*,
 	traits::{
@@ -284,17 +283,6 @@ type NegativeImbalanceOf<T, I> = <<T as Config<I>>::Currency as Currency<
 	<T as frame_system::Config>::AccountId,
 >>::NegativeImbalance;
 
-/// A vote by a member on a candidate application.
-#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
-pub enum OldVote {
-	/// The member has been chosen to be skeptic and has not yet taken any action.
-	Skeptic,
-	/// The member has rejected the candidate's application.
-	Reject,
-	/// The member approves of the candidate's application.
-	Approve,
-}
-
 #[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
 pub struct Vote {
 	approve: bool,
@@ -467,22 +455,17 @@ pub struct GroupParams<Balance> {
 }
 
 pub type GroupParamsFor<T, I> = GroupParams<BalanceOf<T, I>>;
-/*
-pub type FactionIndex = u32;
-
-pub enum Faction {
-	Society,
-	Splinter(FactionIndex),
-}
 
-/// A group is just the rank of a faction.
-pub struct Group {
-	faction: Faction,
-	rank: Rank,
+/// A vote by a member on a candidate application.
+#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub enum OldVote {
+	/// The member has been chosen to be skeptic and has not yet taken any action.
+	Skeptic,
+	/// The member has rejected the candidate's application.
+	Reject,
+	/// The member approves of the candidate's application.
+	Approve,
 }
-*/
-//TODO: Ranks cannot be indexed linearly if we want to do insertions into the ranking system.
-//  Should just be done as Groups DAG.
 
 #[frame_support::pallet]
 pub mod pallet {
@@ -608,6 +591,8 @@ pub mod pallet {
 		AlreadyElevated,
 		/// The skeptic has already been punished for this offence.
 		AlreadyPunished,
+		/// Funds are insufficient to pay off society debts.
+		insufficientFunds,
 	}
 
 	#[pallet::event]
@@ -665,7 +650,6 @@ pub mod pallet {
 	pub type Pot<T: Config<I>, I: 'static = ()> = StorageValue<_, BalanceOf<T, I>, ValueQuery>;
 
 	/// The first member.
-	// TODO: Rename to `Faction` as a map on `FactionIndex`.
 	#[pallet::storage]
 	pub type Founder<T: Config<I>, I: 'static = ()> = StorageValue<_, T::AccountId>;
 
@@ -675,8 +659,6 @@ pub mod pallet {
 
 	/// A hash of the rules of this society concerning membership. Can only be set once and
 	/// only by the founder.
-	// TODO: Should be a map with rules for each rank and faction.
-	// TODO: Rename to `GroupMeta` as a map on `GroupIndex` and include `name: String`.
 	#[pallet::storage]
 	pub type Rules<T: Config<I>, I: 'static = ()> = StorageValue<_, T::Hash>;
 
@@ -684,24 +666,11 @@ pub mod pallet {
 	#[pallet::storage]
 	pub type Members<T: Config<I>, I: 'static = ()> =
 		StorageMap<_, Twox64Concat, T::AccountId, MemberRecord, OptionQuery>;
-	/*
-	// TODO: Migrate from:
-	pub(super) type Vouching<T: Config<I>, I: 'static = ()> =
-		StorageMap<_, Twox64Concat, T::AccountId, VouchingStatus>;
-	pub(super) type Strikes<T: Config<I>, I: 'static = ()> =
-		StorageMap<_, Twox64Concat, T::AccountId, StrikeCount, ValueQuery>;
-	pub type Members<T: Config<I>, I: 'static = ()> =
-		StorageValue<_, Vec<T::AccountId>, ValueQuery>;
-	*/
 
 	/// Information regarding rank-0 payouts, past and future.
 	#[pallet::storage]
 	pub type Payouts<T: Config<I>, I: 'static = ()> =
 		StorageMap<_, Twox64Concat, T::AccountId, PayoutRecordFor<T, I>, ValueQuery>;
-	/*
-	// TODO: Migrate from:
-	pub(super) type Payouts<T: Config<I>, I: 'static = ()> = ???
-	*/
 
 	/// The number of items in `Members` currently. (Doesn't include `SuspendedMembers`.)
 	#[pallet::storage]
@@ -727,11 +696,6 @@ pub mod pallet {
 	pub(super) type Bids<T: Config<I>, I: 'static = ()> =
 		StorageValue<_, BoundedVec<Bid<T::AccountId, BalanceOf<T, I>>, T::MaxBids>, ValueQuery>;
 
-	/*
-	// TODO: Migrate from:
-	pub type Candidates<T: Config<I>, I: 'static = ()> =
-		StorageValue<_, Vec<Bid<T::AccountId, BalanceOf<T, I>>>, ValueQuery>;
-	*/
 	#[pallet::storage]
 	pub type Candidates<T: Config<I>, I: 'static = ()> = StorageMap<_,
 		Blake2_128Concat,
@@ -754,9 +718,6 @@ pub mod pallet {
 		Vote,
 		OptionQuery,
 	>;
-	// TODO: Migrate from:
-	//pub(super) type Votes<T: Config<I>, I: 'static = ()> =
-	//	StorageDoubleMap<_, Twox64Concat, T::AccountId, Twox64Concat, T::AccountId, OldVote>;
 
 	/// At the end of the claim period, this contains the most recently approved members (along with
 	/// their bid and round ID) who is from the most recent round with the lowest bid. They will
@@ -775,11 +736,54 @@ pub mod pallet {
 	#[pallet::storage]
 	pub(super) type DefenderVotes<T: Config<I>, I: 'static = ()> =
 		StorageMap<_, Twox64Concat, T::AccountId, Vote>;
-	/*
-	// TODO: Migrate from
-	pub(super) type DefenderVotes<T: Config<I>, I: 'static = ()> =
-		StorageMap<_, Twox64Concat, T::AccountId, OldVote>;
-	*/
+
+	mod old {
+		use super::{
+			pallet, StorageMap, StorageValue, StorageDoubleMap, Config, BalanceOf, Twox64Concat,
+			ValueQuery, BidKind, VouchingStatus, StrikeCount, Bid,
+		};
+
+		#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+		pub enum Vote {
+			Skeptic,
+			Reject,
+			Approve,
+		}
+
+		#[pallet::storage]
+		pub type Bids<T: Config<I>, I: 'static = ()> =
+			StorageValue<_, Vec<Bid<T::AccountId, BalanceOf<T, I>>>, ValueQuery>;
+		#[pallet::storage]
+		pub type Candidates<T: Config<I>, I: 'static = ()> =
+			StorageValue<_, Vec<Bid<T::AccountId, BalanceOf<T, I>>>, ValueQuery>;
+		#[pallet::storage]
+		pub type Votes<T: Config<I>, I: 'static = ()> =
+			StorageDoubleMap<_, Twox64Concat, T::AccountId, Twox64Concat, T::AccountId, Vote>;
+		#[pallet::storage]
+		pub type SuspendedCandidates<T: Config<I>, I: 'static = ()> =
+			StorageMap<_, Twox64Concat, T::AccountId, (BalanceOf<T, I>, BidKind<T::AccountId, BalanceOf<T, I>>)>;
+		#[pallet::storage]
+		pub type Members<T: Config<I>, I: 'static = ()> =
+			StorageValue<_, Vec<T::AccountId>, ValueQuery>;
+		#[pallet::storage]
+		pub type Vouching<T: Config<I>, I: 'static = ()> =
+			StorageMap<_, Twox64Concat, T::AccountId, VouchingStatus>;
+		#[pallet::storage]
+		pub type Strikes<T: Config<I>, I: 'static = ()> =
+			StorageMap<_, Twox64Concat, T::AccountId, StrikeCount, ValueQuery>;
+		#[pallet::storage]
+		pub type Payouts<T: Config<I>, I: 'static = ()> =
+			StorageMap<_, Twox64Concat, T::AccountId, Vec<(T::BlockNumber, BalanceOf<T, I>)>, ValueQuery>;
+		#[pallet::storage]
+		pub type SuspendedMembers<T: Config<I>, I: 'static = ()> =
+			StorageMap<_, Twox64Concat, T::AccountId, bool, ValueQuery>;
+		#[pallet::storage]
+		pub type Defender<T: Config<I>, I: 'static = ()> =
+			StorageValue<_, T::AccountId>;
+		#[pallet::storage]
+		pub type DefenderVotes<T: Config<I>, I: 'static = ()> =
+			StorageMap<_, Twox64Concat, T::AccountId, Vote>;
+	}
 
 	#[pallet::hooks]
 	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {
@@ -837,14 +841,6 @@ pub mod pallet {
 		}
 	}
 
-	mod migrations {
-		/*
-		fn to_v2() {
-
-		}
-		*/
-	}
-
 	#[pallet::call]
 	impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		/// A user outside of the society can make a bid for entry.
@@ -1078,18 +1074,19 @@ pub mod pallet {
 		/// Repay the payment previously given to the member with the signed origin, remove any
 		/// pending payments, and elevate them from rank 0 to rank 1.
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
-		pub fn waive_repay(origin: OriginFor<T>) -> DispatchResult {
+		pub fn waive_repay(origin: OriginFor<T>, amount: BalanceOf<T, I>) -> DispatchResult {
 			let who = ensure_signed(origin)?;
 			let mut record = Members::<T, I>::get(&who).ok_or(Error::<T, I>::NotMember)?;
 			let mut payout_record = Payouts::<T, I>::get(&who);
 			ensure!(record.rank == 0, Error::<T, I>::AlreadyElevated);
+			ensure!(amount >= payout_record.paid, Error::<T, I>::insufficientFunds);
 
 			T::Currency::transfer(&who, &Self::account_id(), payout_record.paid, AllowDeath)?;
+			payout_record.paid = 0;
 			payout_record.payouts.clear();
 			record.rank = 1;
 			Members::<T, I>::insert(&who, record);
 			Payouts::<T, I>::insert(&who, payout_record);
-
 			Self::deposit_event(Event::<T, I>::Elevated { member: who, rank: 1 });
 
 			Ok(())
@@ -1344,7 +1341,6 @@ impl<T: Config> EnsureOrigin<<T as frame_system::Config>::Origin> for EnsureFoun
 	}
 }
 
-// TODO: Move close to `FromEntropy`?
 struct InputFromRng<'a, T>(&'a mut T);
 impl<'a, T: RngCore> codec::Input for InputFromRng<'a, T> {
 	fn remaining_len(&mut self) -> Result<Option<usize>, codec::Error> {
diff --git a/frame/society/src/mock.rs b/frame/society/src/mock.rs
index 0d756718ea764..b2c5f698be1f2 100644
--- a/frame/society/src/mock.rs
+++ b/frame/society/src/mock.rs
@@ -157,7 +157,9 @@ impl EnvBuilder {
 				let r = b"be cool".to_vec();
 				assert!(Society::found_society(Origin::signed(1), 10, 10, 8, 2, 25, r).is_ok());
 			}
-			f()
+			let r = f();
+			migrations::assert_internal_consistency();
+			r
 		})
 	}
 	pub fn founded(mut self, f: bool) -> Self {

From f8360a82bd35fdb7d00ac25e4887ec484effa39e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bastian=20K=C3=B6cher?= <info@kchr.de>
Date: Tue, 10 May 2022 13:47:41 +0200
Subject: [PATCH 15/43] generate_storage_alias: Rewrite as proc macro attribute

This rewrites the `generate_storage_alias!` declarative macro as proc-macro attribute. While doing
this the name is changed to `storage_alias`. The prefix can now also be the name of a pallet. This
makes storage aliases work in migrations for all kind of chains and not just for the ones that use
predefined prefixes.
---
 frame/bags-list/src/list/tests.rs             |   8 +-
 frame/bags-list/src/migrations.rs             |   5 +-
 frame/contracts/src/migration.rs              |  52 +-
 frame/elections-phragmen/src/migrations/v3.rs |  95 ++--
 frame/offences/src/migration.rs               |   8 +-
 frame/staking/src/migrations.rs               |  28 +-
 frame/support/procedural/src/lib.rs           |   8 +
 frame/support/procedural/src/storage_alias.rs | 524 ++++++++++++++++++
 frame/support/src/lib.rs                      | 221 ++------
 .../support/src/storage/bounded_btree_map.rs  |  14 +-
 .../support/src/storage/bounded_btree_set.rs  |  15 +-
 frame/support/src/storage/bounded_vec.rs      |  14 +-
 .../src/storage/generator/double_map.rs       |   6 +-
 frame/support/src/storage/generator/map.rs    |   3 +-
 frame/support/src/storage/generator/nmap.rs   |  16 +-
 frame/support/src/storage/mod.rs              |  18 +-
 frame/support/src/storage/types/nmap.rs       |   8 +-
 frame/support/src/storage/weak_bounded_vec.rs |  13 +-
 frame/system/src/migrations/mod.rs            |  66 +--
 19 files changed, 762 insertions(+), 360 deletions(-)
 create mode 100644 frame/support/procedural/src/storage_alias.rs

diff --git a/frame/bags-list/src/list/tests.rs b/frame/bags-list/src/list/tests.rs
index ff7dd2871c237..66c2ad8ab95b5 100644
--- a/frame/bags-list/src/list/tests.rs
+++ b/frame/bags-list/src/list/tests.rs
@@ -368,11 +368,9 @@ mod list {
 			assert_eq!(crate::ListNodes::<Runtime>::count(), 4);
 			// we do some wacky stuff here to get access to the counter, since it is (reasonably)
 			// not exposed as mutable in any sense.
-			frame_support::generate_storage_alias!(
-				BagsList,
-				CounterForListNodes
-				=> Value<u32, frame_support::pallet_prelude::ValueQuery>
-			);
+			#[frame_support::storage_alias]
+			type CounterForListNodes<T> =
+				Value<Pallet<T: Config>, u32, frame_support::pallet_prelude::ValueQuery>;
 			CounterForListNodes::mutate(|counter| *counter += 1);
 			assert_eq!(crate::ListNodes::<Runtime>::count(), 5);
 
diff --git a/frame/bags-list/src/migrations.rs b/frame/bags-list/src/migrations.rs
index 696733e8c7ba5..42606ff7e635d 100644
--- a/frame/bags-list/src/migrations.rs
+++ b/frame/bags-list/src/migrations.rs
@@ -30,11 +30,12 @@ impl<T: crate::Config> OnRuntimeUpgrade for CheckCounterPrefix<T> {
 	fn pre_upgrade() -> Result<(), &'static str> {
 		use frame_support::ensure;
 		// The old explicit storage item.
-		frame_support::generate_storage_alias!(BagsList, CounterForListNodes => Value<u32>);
+		#[frame_support::storage_alias]
+		type CounterForListNodes<T> = Value<crate::Pallet<T: crate::Config>, u32>;
 
 		// ensure that a value exists in the counter struct.
 		ensure!(
-			crate::ListNodes::<T>::count() == CounterForListNodes::get().unwrap(),
+			crate::ListNodes::<T>::count() == CounterForListNodes::<T>::get().unwrap(),
 			"wrong list node counter"
 		);
 
diff --git a/frame/contracts/src/migration.rs b/frame/contracts/src/migration.rs
index 035e3b4409cf9..827120a9ab96a 100644
--- a/frame/contracts/src/migration.rs
+++ b/frame/contracts/src/migration.rs
@@ -18,11 +18,8 @@
 use crate::{BalanceOf, CodeHash, Config, Pallet, TrieId, Weight};
 use codec::{Decode, Encode};
 use frame_support::{
-	codec, generate_storage_alias,
-	pallet_prelude::*,
-	storage::migration,
-	traits::{Get, PalletInfoAccess},
-	Identity, Twox64Concat,
+	codec, pallet_prelude::*, storage::migration, storage_alias, traits::Get, Identity,
+	Twox64Concat,
 };
 use sp_std::{marker::PhantomData, prelude::*};
 
@@ -119,15 +116,12 @@ mod v5 {
 		trie_id: TrieId,
 	}
 
-	generate_storage_alias!(
-		Contracts,
-		ContractInfoOf<T: Config> => Map<(Twox64Concat, T::AccountId), ContractInfo<T>>
-	);
+	#[storage_alias]
+	type ContractInfoOf<T> =
+		Map<Pallet<T>, Twox64Concat, <T as Config>::AccountId, ContractInfo<T>>;
 
-	generate_storage_alias!(
-		Contracts,
-		DeletionQueue => Value<Vec<DeletedContract>>
-	);
+	#[storage_alias]
+	type DeletionQueue<T> = Value<Pallet<T>, Vec<DeletedContract>>;
 
 	pub fn migrate<T: Config>() -> Weight {
 		let mut weight: Weight = 0;
@@ -204,20 +198,15 @@ mod v6 {
 
 	type ContractInfo<T> = RawContractInfo<CodeHash<T>, BalanceOf<T>>;
 
-	generate_storage_alias!(
-		Contracts,
-		ContractInfoOf<T: Config> => Map<(Twox64Concat, T::AccountId), ContractInfo<T>>
-	);
+	#[storage_alias]
+	type ContractInfoOf<T> =
+		Map<Pallet<T>, Twox64Concat, <T as Config>::AccountId, ContractInfo<T>>;
 
-	generate_storage_alias!(
-		Contracts,
-		CodeStorage<T: Config> => Map<(Identity, CodeHash<T>), PrefabWasmModule>
-	);
+	#[storage_alias]
+	type CodeStorage<T> = Map<Pallet<T>, Identity, CodeHash<T>, PrefabWasmModule>;
 
-	generate_storage_alias!(
-		Contracts,
-		OwnerInfoOf<T: Config> => Map<(Identity, CodeHash<T>), OwnerInfo<T>>
-	);
+	#[storage_alias]
+	type OwnerInfoOf<T> = Map<Pallet<T>, Identity, CodeHash<T>, OwnerInfo<T>>;
 
 	pub fn migrate<T: Config>() -> Weight {
 		let mut weight: Weight = 0;
@@ -261,14 +250,11 @@ mod v7 {
 	use super::*;
 
 	pub fn migrate<T: Config>() -> Weight {
-		generate_storage_alias!(
-			Contracts,
-			AccountCounter => Value<u64, ValueQuery>
-		);
-		generate_storage_alias!(
-			Contracts,
-			Nonce => Value<u64, ValueQuery>
-		);
+		#[storage_alias]
+		type AccountCounter<T> = Value<Pallet<T: Config>, u64, ValueQuery>;
+		#[storage_alias]
+		type Nonce<T> = Value<Pallet<T: Config>, u64, ValueQuery>;
+
 		Nonce::set(AccountCounter::take());
 		T::DbWeight::get().reads_writes(1, 2)
 	}
diff --git a/frame/elections-phragmen/src/migrations/v3.rs b/frame/elections-phragmen/src/migrations/v3.rs
index c6a7ce7e7ca1b..815bdf71591ea 100644
--- a/frame/elections-phragmen/src/migrations/v3.rs
+++ b/frame/elections-phragmen/src/migrations/v3.rs
@@ -17,12 +17,10 @@
 
 //! Migrations to version [`3.0.0`], as denoted by the changelog.
 
+use crate::{Config, Pallet};
 use codec::{Decode, Encode, FullCodec};
 use frame_support::{
-	pallet_prelude::ValueQuery,
-	traits::{PalletInfoAccess, StorageVersion},
-	weights::Weight,
-	RuntimeDebug, Twox64Concat,
+	pallet_prelude::ValueQuery, traits::StorageVersion, weights::Weight, RuntimeDebug, Twox64Concat,
 };
 use sp_std::prelude::*;
 
@@ -42,9 +40,6 @@ struct Voter<AccountId, Balance> {
 
 /// Trait to implement to give information about types used for migration
 pub trait V2ToV3 {
-	/// The elections-phragmen pallet.
-	type Pallet: 'static + PalletInfoAccess;
-
 	/// System config account id
 	type AccountId: 'static + FullCodec;
 
@@ -52,30 +47,30 @@ pub trait V2ToV3 {
 	type Balance: 'static + FullCodec + Copy;
 }
 
-frame_support::generate_storage_alias!(
-	PhragmenElection, Candidates<T: V2ToV3> => Value<
-		Vec<(T::AccountId, T::Balance)>,
-		ValueQuery
-	>
-);
-frame_support::generate_storage_alias!(
-	PhragmenElection, Members<T: V2ToV3> => Value<
-		Vec<SeatHolder<T::AccountId, T::Balance>>,
-		ValueQuery
-	>
-);
-frame_support::generate_storage_alias!(
-	PhragmenElection, RunnersUp<T: V2ToV3> => Value<
-		Vec<SeatHolder<T::AccountId, T::Balance>>,
-		ValueQuery
-	>
-);
-frame_support::generate_storage_alias!(
-	PhragmenElection, Voting<T: V2ToV3> => Map<
-		(Twox64Concat, T::AccountId),
-		Voter<T::AccountId, T::Balance>
-	>
-);
+#[frame_support::storage_alias]
+type Candidates<V, T> =
+	Value<Pallet<T: Config>, Vec<(<V as V2ToV3>::AccountId, <V as V2ToV3>::Balance)>, ValueQuery>;
+
+#[frame_support::storage_alias]
+type Members<V, T> = Value<
+	Pallet<T: Config>,
+	Vec<SeatHolder<<V as V2ToV3>::AccountId, <V as V2ToV3>::Balance>>,
+	ValueQuery,
+>;
+
+#[frame_support::storage_alias]
+type RunnersUp<V, T> = Value<
+	Pallet<T: Config>,
+	Vec<SeatHolder<<V as V2ToV3>::AccountId, <V as V2ToV3>::Balance>>,
+	ValueQuery,
+>;
+
+#[frame_support::storage_alias]
+type Voting<V, T> = Map<
+	Pallet<T: Config>,
+	(Twox64Concat, T::AccountId),
+	Voter<<V as V2ToV3>::AccountId, <V as V2ToV3>::Balance>,
+>;
 
 /// Apply all of the migrations from 2 to 3.
 ///
@@ -86,7 +81,10 @@ frame_support::generate_storage_alias!(
 ///
 /// Be aware that this migration is intended to be used only for the mentioned versions. Use
 /// with care and run at your own risk.
-pub fn apply<T: V2ToV3>(old_voter_bond: T::Balance, old_candidacy_bond: T::Balance) -> Weight {
+pub fn apply<V: V2ToV3, T: Config>(
+	old_voter_bond: V::Balance,
+	old_candidacy_bond: V::Balance,
+) -> Weight {
 	let storage_version = StorageVersion::get::<T::Pallet>();
 	log::info!(
 		target: "runtime::elections-phragmen",
@@ -95,12 +93,12 @@ pub fn apply<T: V2ToV3>(old_voter_bond: T::Balance, old_candidacy_bond: T::Balan
 	);
 
 	if storage_version <= 2 {
-		migrate_voters_to_recorded_deposit::<T>(old_voter_bond);
-		migrate_candidates_to_recorded_deposit::<T>(old_candidacy_bond);
-		migrate_runners_up_to_recorded_deposit::<T>(old_candidacy_bond);
-		migrate_members_to_recorded_deposit::<T>(old_candidacy_bond);
+		migrate_voters_to_recorded_deposit::<V, T>(old_voter_bond);
+		migrate_candidates_to_recorded_deposit::<V, T>(old_candidacy_bond);
+		migrate_runners_up_to_recorded_deposit::<V, T>(old_candidacy_bond);
+		migrate_members_to_recorded_deposit::<V, T>(old_candidacy_bond);
 
-		StorageVersion::new(3).put::<T::Pallet>();
+		StorageVersion::new(3).put::<Pallet<T>>();
 
 		Weight::max_value()
 	} else {
@@ -114,21 +112,21 @@ pub fn apply<T: V2ToV3>(old_voter_bond: T::Balance, old_candidacy_bond: T::Balan
 }
 
 /// Migrate from the old legacy voting bond (fixed) to the new one (per-vote dynamic).
-pub fn migrate_voters_to_recorded_deposit<T: V2ToV3>(old_deposit: T::Balance) {
-	<Voting<T>>::translate::<(T::Balance, Vec<T::AccountId>), _>(|_who, (stake, votes)| {
+pub fn migrate_voters_to_recorded_deposit<V: V2ToV3, T: Config>(old_deposit: V::Balance) {
+	<Voting<V, T>>::translate::<(V::Balance, Vec<V::AccountId>), _>(|_who, (stake, votes)| {
 		Some(Voter { votes, stake, deposit: old_deposit })
 	});
 
 	log::info!(
 		target: "runtime::elections-phragmen",
 		"migrated {} voter accounts.",
-		<Voting<T>>::iter().count(),
+		<Voting<V, T>>::iter().count(),
 	);
 }
 
 /// Migrate all candidates to recorded deposit.
-pub fn migrate_candidates_to_recorded_deposit<T: V2ToV3>(old_deposit: T::Balance) {
-	let _ = <Candidates<T>>::translate::<Vec<T::AccountId>, _>(|maybe_old_candidates| {
+pub fn migrate_candidates_to_recorded_deposit<V: V2ToV3, T: Config>(old_deposit: V::Balance) {
+	let _ = <Candidates<V, T>>::translate::<Vec<V::AccountId>, _>(|maybe_old_candidates| {
 		maybe_old_candidates.map(|old_candidates| {
 			log::info!(
 				target: "runtime::elections-phragmen",
@@ -141,8 +139,8 @@ pub fn migrate_candidates_to_recorded_deposit<T: V2ToV3>(old_deposit: T::Balance
 }
 
 /// Migrate all members to recorded deposit.
-pub fn migrate_members_to_recorded_deposit<T: V2ToV3>(old_deposit: T::Balance) {
-	let _ = <Members<T>>::translate::<Vec<(T::AccountId, T::Balance)>, _>(|maybe_old_members| {
+pub fn migrate_members_to_recorded_deposit<V: V2ToV3, T: Config>(old_deposit: V::Balance) {
+	let _ = <Members<V, T>>::translate::<Vec<(V::AccountId, V::Balance)>, _>(|maybe_old_members| {
 		maybe_old_members.map(|old_members| {
 			log::info!(
 				target: "runtime::elections-phragmen",
@@ -158,9 +156,9 @@ pub fn migrate_members_to_recorded_deposit<T: V2ToV3>(old_deposit: T::Balance) {
 }
 
 /// Migrate all runners-up to recorded deposit.
-pub fn migrate_runners_up_to_recorded_deposit<T: V2ToV3>(old_deposit: T::Balance) {
-	let _ =
-		<RunnersUp<T>>::translate::<Vec<(T::AccountId, T::Balance)>, _>(|maybe_old_runners_up| {
+pub fn migrate_runners_up_to_recorded_deposit<V: V2ToV3, T: Config>(old_deposit: V::Balance) {
+	let _ = <RunnersUp<V, T>>::translate::<Vec<(V::AccountId, V::Balance)>, _>(
+		|maybe_old_runners_up| {
 			maybe_old_runners_up.map(|old_runners_up| {
 				log::info!(
 					target: "runtime::elections-phragmen",
@@ -172,5 +170,6 @@ pub fn migrate_runners_up_to_recorded_deposit<T: V2ToV3>(old_deposit: T::Balance
 					.map(|(who, stake)| SeatHolder { who, stake, deposit: old_deposit })
 					.collect::<Vec<_>>()
 			})
-		});
+		},
+	);
 }
diff --git a/frame/offences/src/migration.rs b/frame/offences/src/migration.rs
index 0d6c98b564cb1..72178fe389568 100644
--- a/frame/offences/src/migration.rs
+++ b/frame/offences/src/migration.rs
@@ -17,7 +17,7 @@
 
 use super::{Config, OffenceDetails, Perbill, SessionIndex};
 use frame_support::{
-	generate_storage_alias, pallet_prelude::ValueQuery, traits::Get, weights::Weight,
+	storage_alias, pallet_prelude::ValueQuery, traits::Get, weights::Weight,
 };
 use sp_staking::offence::{DisableStrategy, OnOffenceHandler};
 use sp_std::vec::Vec;
@@ -31,10 +31,8 @@ type DeferredOffenceOf<T> = (
 
 // Deferred reports that have been rejected by the offence handler and need to be submitted
 // at a later time.
-generate_storage_alias!(
-	Offences,
-	DeferredOffences<T: Config> => Value<Vec<DeferredOffenceOf<T>>, ValueQuery>
-);
+#[storage_alias]
+type DeferredOffences<T> = Value<Pallet<T: Config>, Vec<DeferredOffenceOf<T>>, ValueQuery>;
 
 pub fn remove_deferred_storage<T: Config>() -> Weight {
 	let mut weight = T::DbWeight::get().reads_writes(1, 1);
diff --git a/frame/staking/src/migrations.rs b/frame/staking/src/migrations.rs
index 96c905f4e5942..60666083644b0 100644
--- a/frame/staking/src/migrations.rs
+++ b/frame/staking/src/migrations.rs
@@ -139,10 +139,12 @@ pub mod v8 {
 
 pub mod v7 {
 	use super::*;
-	use frame_support::generate_storage_alias;
+	use frame_support::storage_alias;
 
-	generate_storage_alias!(Staking, CounterForValidators => Value<u32>);
-	generate_storage_alias!(Staking, CounterForNominators => Value<u32>);
+	#[storage_alias]
+	type CounterForValidators<T> = Value<Pallet<T: Config>, u32>;
+	#[storage_alias]
+	type CounterForNominators<T> = Value<Pallet<T: Config>, u32>;
 
 	pub fn pre_migrate<T: Config>() -> Result<(), &'static str> {
 		assert!(
@@ -176,15 +178,21 @@ pub mod v7 {
 
 pub mod v6 {
 	use super::*;
-	use frame_support::{generate_storage_alias, traits::Get, weights::Weight};
+	use frame_support::{storage_alias, traits::Get, weights::Weight};
 
 	// NOTE: value type doesn't matter, we just set it to () here.
-	generate_storage_alias!(Staking, SnapshotValidators => Value<()>);
-	generate_storage_alias!(Staking, SnapshotNominators => Value<()>);
-	generate_storage_alias!(Staking, QueuedElected => Value<()>);
-	generate_storage_alias!(Staking, QueuedScore => Value<()>);
-	generate_storage_alias!(Staking, EraElectionStatus => Value<()>);
-	generate_storage_alias!(Staking, IsCurrentSessionFinal => Value<()>);
+	#[storage_alias]
+	type SnapshotValidators<T> = Value<Pallet<T: Config>, ()>;
+	#[storage_alias]
+	type SnapshotNominators<T> = Value<Pallet<T: Config>, ()>;
+	#[storage_alias]
+	type QueuedElected<T> = Value<Pallet<T: Config>, ()>;
+	#[storage_alias]
+	type QueuedScore<T> = Value<Pallet<T: Config>, ()>;
+	#[storage_alias]
+	type EraElectionStatus<T> = Value<Pallet<T: Config>, ()>;
+	#[storage_alias]
+	type IsCurrentSessionFinal<T> = Value<Pallet<T: Config>, ()>;
 
 	/// check to execute prior to migration.
 	pub fn pre_migrate<T: Config>() -> Result<(), &'static str> {
diff --git a/frame/support/procedural/src/lib.rs b/frame/support/procedural/src/lib.rs
index 92564e94493c1..f4e64cb949aa9 100644
--- a/frame/support/procedural/src/lib.rs
+++ b/frame/support/procedural/src/lib.rs
@@ -25,6 +25,7 @@ mod crate_version;
 mod debug_no_bound;
 mod default_no_bound;
 mod dummy_part_checker;
+mod storage_alias;
 mod key_prefix;
 mod match_and_insert;
 mod pallet;
@@ -575,3 +576,10 @@ pub fn derive_pallet_error(input: TokenStream) -> TokenStream {
 pub fn __create_tt_macro(input: TokenStream) -> TokenStream {
 	tt_macro::create_tt_return_macro(input)
 }
+
+#[proc_macro_attribute]
+pub fn storage_alias(_: TokenStream, input: TokenStream) -> TokenStream {
+	storage_alias::storage_alias(input.into())
+		.unwrap_or_else(|r| r.into_compile_error())
+		.into()
+}
diff --git a/frame/support/procedural/src/storage_alias.rs b/frame/support/procedural/src/storage_alias.rs
new file mode 100644
index 0000000000000..39760661dd911
--- /dev/null
+++ b/frame/support/procedural/src/storage_alias.rs
@@ -0,0 +1,524 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2020-2022 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Implementation of the `storage_alias` attribute macro.
+
+use frame_support_procedural_tools::generate_crate_access_2018;
+use proc_macro2::{Span, TokenStream};
+use quote::{quote, ToTokens};
+use syn::{
+	ext::IdentExt,
+	parenthesized,
+	parse::{Parse, ParseStream},
+	punctuated::Punctuated,
+	token, Attribute, Error, Ident, Result, Token, Type, TypeParam, Visibility,
+};
+
+/// Represents a path that only consists of [`Ident`] separated by `::`.
+struct SimplePath {
+	leading_colon: Option<Token![::]>,
+	segments: Punctuated<Ident, Token![::]>,
+}
+
+impl SimplePath {
+	/// Returns the [`Ident`] of this path.
+	///
+	/// It only returns `Some(_)` if there is exactly one element and no leading colon.
+	fn get_ident(&self) -> Option<&Ident> {
+		if self.segments.len() != 1 || self.leading_colon.is_some() {
+			None
+		} else {
+			self.segments.first()
+		}
+	}
+}
+
+impl Parse for SimplePath {
+	fn parse(input: ParseStream<'_>) -> Result<Self> {
+		Ok(Self {
+			leading_colon: if input.peek(Token![::]) { Some(input.parse()?) } else { None },
+			segments: Punctuated::parse_separated_nonempty_with(input, |p| Ident::parse_any(p))?,
+		})
+	}
+}
+
+impl ToTokens for SimplePath {
+	fn to_tokens(&self, tokens: &mut TokenStream) {
+		self.leading_colon.to_tokens(tokens);
+		self.segments.to_tokens(tokens);
+	}
+}
+
+/// Represents generics which only support [`TypeParam`] separated by commas.
+struct SimpleGenerics {
+	lt_token: Token![<],
+	params: Punctuated<TypeParam, token::Comma>,
+	gt_token: Token![>],
+}
+
+impl SimpleGenerics {
+	/// Returns the generics for types declarations etc.
+	fn type_generics(&self) -> impl Iterator<Item = &Ident> {
+		self.params.iter().map(|p| &p.ident)
+	}
+
+	/// Returns the generics for the `impl` block.
+	fn impl_generics(&self) -> impl Iterator<Item = &TypeParam> {
+		self.params.iter()
+	}
+
+	/// Returns `true` if all parameters have at least one trait bound.
+	fn all_have_trait_bounds(&self) -> bool {
+		self.params
+			.iter()
+			.all(|p| p.bounds.iter().any(|b| matches!(b, syn::TypeParamBound::Trait(_))))
+	}
+}
+
+impl Parse for SimpleGenerics {
+	fn parse(input: ParseStream<'_>) -> Result<Self> {
+		Ok(Self {
+			lt_token: input.parse()?,
+			params: Punctuated::parse_separated_nonempty(input)?,
+			gt_token: input.parse()?,
+		})
+	}
+}
+
+impl ToTokens for SimpleGenerics {
+	fn to_tokens(&self, tokens: &mut TokenStream) {
+		self.lt_token.to_tokens(tokens);
+		self.params.to_tokens(tokens);
+		self.gt_token.to_tokens(tokens);
+	}
+}
+
+mod storage_types {
+	syn::custom_keyword!(Value);
+	syn::custom_keyword!(Map);
+	syn::custom_keyword!(DoubleMap);
+	syn::custom_keyword!(NMap);
+}
+
+/// The supported storage types
+enum StorageType {
+	Value {
+		_kw: storage_types::Value,
+		_lt_token: Token![<],
+		prefix: SimplePath,
+		prefix_generics: Option<SimpleGenerics>,
+		_value_comma: Token![,],
+		value_ty: Type,
+		query_type: Option<(Token![,], Type)>,
+		_trailing_comma: Option<Token![,]>,
+		_gt_token: Token![>],
+	},
+	Map {
+		_kw: storage_types::Map,
+		_lt_token: Token![<],
+		prefix: SimplePath,
+		prefix_generics: Option<SimpleGenerics>,
+		_hasher_comma: Token![,],
+		hasher_ty: Type,
+		_key_comma: Token![,],
+		key_ty: Type,
+		_value_comma: Token![,],
+		value_ty: Type,
+		query_type: Option<(Token![,], Type)>,
+		_trailing_comma: Option<Token![,]>,
+		_gt_token: Token![>],
+	},
+	DoubleMap {
+		_kw: storage_types::DoubleMap,
+		_lt_token: Token![<],
+		prefix: SimplePath,
+		prefix_generics: Option<SimpleGenerics>,
+		_hasher1_comma: Token![,],
+		hasher1_ty: Type,
+		_key1_comma: Token![,],
+		key1_ty: Type,
+		_hasher2_comma: Token![,],
+		hasher2_ty: Type,
+		_key2_comma: Token![,],
+		key2_ty: Type,
+		_value_comma: Token![,],
+		value_ty: Type,
+		query_type: Option<(Token![,], Type)>,
+		_trailing_comma: Option<Token![,]>,
+		_gt_token: Token![>],
+	},
+	NMap {
+		_kw: storage_types::NMap,
+		_lt_token: Token![<],
+		prefix: SimplePath,
+		prefix_generics: Option<SimpleGenerics>,
+		_paren_comma: Token![,],
+		_paren_token: token::Paren,
+		key_types: Punctuated<Type, Token![,]>,
+		_value_comma: Token![,],
+		value_ty: Type,
+		query_type: Option<(Token![,], Type)>,
+		_trailing_comma: Option<Token![,]>,
+		_gt_token: Token![>],
+	},
+}
+
+impl StorageType {
+	/// Generate the actual type declaration.
+	fn generate_type_declaration(
+		&self,
+		crate_: &Ident,
+		storage_instance: &StorageInstance,
+		storage_name: &Ident,
+		storage_generics: Option<&SimpleGenerics>,
+		visibility: &Visibility,
+		attributes: &[Attribute],
+	) -> TokenStream {
+		let storage_instance = &storage_instance.name;
+		let type_generics = self
+			.prefix_generics()
+			.map(|g| {
+				let g = g.type_generics();
+				quote! { <#( #g ),*> }
+			})
+			.unwrap_or_default();
+		let attributes = attributes.iter();
+
+		match self {
+			Self::Value { value_ty, query_type, .. } => {
+				let query_type = query_type.as_ref().map(|(c, t)| quote!(#c #t));
+
+				quote! {
+					#( #attributes )*
+					#visibility type #storage_name #storage_generics = #crate_::storage::types::StorageValue<
+						#storage_instance #type_generics,
+						#value_ty
+						#query_type
+					>;
+				}
+			},
+			Self::Map { value_ty, query_type, hasher_ty, key_ty, .. } => {
+				let query_type = query_type.as_ref().map(|(c, t)| quote!(#c #t));
+
+				quote! {
+					#( #attributes )*
+					#visibility type #storage_name #storage_generics = #crate_::storage::types::StorageMap<
+						#storage_instance #type_generics,
+						#hasher_ty,
+						#key_ty,
+						#value_ty
+						#query_type
+					>;
+				}
+			},
+			Self::DoubleMap {
+				value_ty,
+				query_type,
+				hasher1_ty,
+				key1_ty,
+				hasher2_ty,
+				key2_ty,
+				..
+			} => {
+				let query_type = query_type.as_ref().map(|(c, t)| quote!(#c #t));
+
+				quote! {
+					#( #attributes )*
+					#visibility type #storage_name #storage_generics = #crate_::storage::types::StorageDoubleMap<
+						#storage_instance #type_generics,
+						#hasher1_ty,
+						#key1_ty,
+						#hasher2_ty,
+						#key2_ty,
+						#value_ty
+						#query_type
+					>;
+				}
+			},
+			Self::NMap { value_ty, query_type, key_types, .. } => {
+				let query_type = query_type.as_ref().map(|(c, t)| quote!(#c #t));
+				let key_types = key_types.iter();
+
+				quote! {
+					#( #attributes )*
+					#visibility type #storage_name #storage_generics = #crate_::storage::types::StorageNMap<
+						#storage_instance #type_generics,
+						( #( #key_types ),* ),
+						#value_ty
+						#query_type
+					>;
+				}
+			},
+		}
+	}
+
+	/// The prefix for this storage type.
+	fn prefix(&self) -> &SimplePath {
+		match self {
+			Self::Value { prefix, .. } |
+			Self::Map { prefix, .. } |
+			Self::NMap { prefix, .. } |
+			Self::DoubleMap { prefix, .. } => prefix,
+		}
+	}
+
+	/// The prefix generics for this storage type.
+	fn prefix_generics(&self) -> Option<&SimpleGenerics> {
+		match self {
+			Self::Value { prefix_generics, .. } |
+			Self::Map { prefix_generics, .. } |
+			Self::NMap { prefix_generics, .. } |
+			Self::DoubleMap { prefix_generics, .. } => prefix_generics.as_ref(),
+		}
+	}
+}
+
+impl Parse for StorageType {
+	fn parse(input: ParseStream<'_>) -> Result<Self> {
+		let lookahead = input.lookahead1();
+
+		let parse_query_type = |input: ParseStream<'_>| -> Result<Option<(Token![,], Type)>> {
+			if input.peek(Token![,]) && !input.peek2(Token![>]) {
+				Ok(Some((input.parse()?, input.parse()?)))
+			} else {
+				Ok(None)
+			}
+		};
+
+		let parse_pallet_generics = |input: ParseStream<'_>| -> Result<Option<SimpleGenerics>> {
+			let lookahead = input.lookahead1();
+			if lookahead.peek(Token![<]) {
+				Some(input.parse()).transpose()
+			} else if lookahead.peek(Token![,]) {
+				Ok(None)
+			} else {
+				Err(lookahead.error())
+			}
+		};
+
+		if lookahead.peek(storage_types::Value) {
+			Ok(Self::Value {
+				_kw: input.parse()?,
+				_lt_token: input.parse()?,
+				prefix: input.parse()?,
+				prefix_generics: parse_pallet_generics(input)?,
+				_value_comma: input.parse()?,
+				value_ty: input.parse()?,
+				query_type: parse_query_type(input)?,
+				_trailing_comma: input.peek(Token![,]).then(|| input.parse()).transpose()?,
+				_gt_token: input.parse()?,
+			})
+		} else if lookahead.peek(storage_types::Map) {
+			Ok(Self::Map {
+				_kw: input.parse()?,
+				_lt_token: input.parse()?,
+				prefix: input.parse()?,
+				prefix_generics: parse_pallet_generics(input)?,
+				_hasher_comma: input.parse()?,
+				hasher_ty: input.parse()?,
+				_key_comma: input.parse()?,
+				key_ty: input.parse()?,
+				_value_comma: input.parse()?,
+				value_ty: input.parse()?,
+				query_type: parse_query_type(input)?,
+				_trailing_comma: input.peek(Token![,]).then(|| input.parse()).transpose()?,
+				_gt_token: input.parse()?,
+			})
+		} else if lookahead.peek(storage_types::DoubleMap) {
+			Ok(Self::DoubleMap {
+				_kw: input.parse()?,
+				_lt_token: input.parse()?,
+				prefix: input.parse()?,
+				prefix_generics: parse_pallet_generics(input)?,
+				_hasher1_comma: input.parse()?,
+				hasher1_ty: input.parse()?,
+				_key1_comma: input.parse()?,
+				key1_ty: input.parse()?,
+				_hasher2_comma: input.parse()?,
+				hasher2_ty: input.parse()?,
+				_key2_comma: input.parse()?,
+				key2_ty: input.parse()?,
+				_value_comma: input.parse()?,
+				value_ty: input.parse()?,
+				query_type: parse_query_type(input)?,
+				_trailing_comma: input.peek(Token![,]).then(|| input.parse()).transpose()?,
+				_gt_token: input.parse()?,
+			})
+		} else if lookahead.peek(storage_types::NMap) {
+			let content;
+			Ok(Self::NMap {
+				_kw: input.parse()?,
+				_lt_token: input.parse()?,
+				prefix: input.parse()?,
+				prefix_generics: parse_pallet_generics(input)?,
+				_paren_comma: input.parse()?,
+				_paren_token: parenthesized!(content in input),
+				key_types: Punctuated::parse_terminated(&content)?,
+				_value_comma: input.parse()?,
+				value_ty: input.parse()?,
+				query_type: parse_query_type(input)?,
+				_trailing_comma: input.peek(Token![,]).then(|| input.parse()).transpose()?,
+				_gt_token: input.parse()?,
+			})
+		} else {
+			Err(lookahead.error())
+		}
+	}
+}
+
+/// The input expected by this macro.
+struct Input {
+	attributes: Vec<Attribute>,
+	visibility: Visibility,
+	_type: Token![type],
+	storage_name: Ident,
+	storage_generics: Option<SimpleGenerics>,
+	_equal: Token![=],
+	storage_type: StorageType,
+	_semicolon: Token![;],
+}
+
+impl Parse for Input {
+	fn parse(input: ParseStream<'_>) -> Result<Self> {
+		let attributes = input.call(Attribute::parse_outer)?;
+		let visibility = input.parse()?;
+		let _type = input.parse()?;
+		let storage_name = input.parse()?;
+
+		let lookahead = input.lookahead1();
+		let (storage_generics, _equal) = if lookahead.peek(Token![<]) {
+			(Some(input.parse()?), input.parse()?)
+		} else if lookahead.peek(Token![=]) {
+			(None, input.parse()?)
+		} else {
+			return Err(lookahead.error())
+		};
+
+		let storage_type = input.parse()?;
+
+		let _semicolon = input.parse()?;
+
+		Ok(Self {
+			attributes,
+			visibility,
+			_type,
+			storage_name,
+			storage_generics,
+			_equal,
+			storage_type,
+			_semicolon,
+		})
+	}
+}
+
+/// Implementation of the `storage_alias` attribute macro.
+pub fn storage_alias(input: TokenStream) -> Result<TokenStream> {
+	let input = syn::parse2::<Input>(input)?;
+	let crate_ = generate_crate_access_2018("frame-support")?;
+
+	if let Some(ref generics) = input.storage_generics {
+		if !generics.all_have_trait_bounds() {
+			return Err(Error::new_spanned(
+				generics,
+				"The pallet generics require to be bound by the \
+				 pallet `Config` trait and optional `Instance` trait.",
+			))
+		}
+	}
+
+	let storage_instance = generate_storage_instance(
+		&crate_,
+		&input.storage_name,
+		input.storage_type.prefix(),
+		input.storage_type.prefix_generics(),
+		&input.visibility,
+	)?;
+
+	let definition = input.storage_type.generate_type_declaration(
+		&crate_,
+		&storage_instance,
+		&input.storage_name,
+		input.storage_generics.as_ref(),
+		&input.visibility,
+		&input.attributes,
+	);
+
+	let storage_instance_code = storage_instance.code;
+
+	Ok(quote! {
+		#storage_instance_code
+
+		#definition
+	})
+}
+
+/// The storage instance to use for the storage alias.
+struct StorageInstance {
+	name: Ident,
+	code: TokenStream,
+}
+
+/// Generate the [`StorageInstance`] for the storage alias.
+fn generate_storage_instance(
+	crate_: &Ident,
+	storage_name: &Ident,
+	prefix: &SimplePath,
+	prefix_generics: Option<&SimpleGenerics>,
+	visibility: &Visibility,
+) -> Result<StorageInstance> {
+	let (pallet_prefix, impl_generics, type_generics) =
+		if let Some(prefix_generics) = prefix_generics {
+			let type_generics = prefix_generics.type_generics();
+			let type_generics2 = prefix_generics.type_generics();
+			let impl_generics = prefix_generics.impl_generics();
+
+			(
+				quote! {
+					<#prefix < #( #type_generics2 ),* > as #crate_::traits::PalletInfoAccess>::name()
+				},
+				quote!( #( #impl_generics ),* ),
+				quote!( #( #type_generics ),* ),
+			)
+		} else if let Some(prefix) = prefix.get_ident() {
+			let prefix_str = prefix.to_string();
+
+			(quote!(#prefix_str), quote!(), quote!())
+		} else {
+			return Err(Error::new_spanned(
+				prefix,
+				"If there are no generics, the prefix is only allowed to be an identifier.",
+			))
+		};
+
+	let name = Ident::new(&format!("{}_Storage_Instance", storage_name), Span::call_site());
+	let storage_name_str = storage_name.to_string();
+
+	// Implement `StorageInstance` trait.
+	let code = quote! {
+		#visibility struct #name< #impl_generics >(#crate_::sp_std::marker::PhantomData<(#type_generics)>);
+
+		impl<#impl_generics> #crate_::traits::StorageInstance for #name< #type_generics > {
+			fn pallet_prefix() -> &'static str {
+				#pallet_prefix
+			}
+
+			const STORAGE_PREFIX: &'static str = #storage_name_str;
+		}
+	};
+
+	Ok(StorageInstance { name, code })
+}
diff --git a/frame/support/src/lib.rs b/frame/support/src/lib.rs
index 3e84c009b5ca6..4cd740c52162a 100644
--- a/frame/support/src/lib.rs
+++ b/frame/support/src/lib.rs
@@ -166,178 +166,69 @@ macro_rules! bounded_btree_map {
 /// Useful for creating a *storage-like* struct for test and migrations.
 ///
 /// ```
-/// # use frame_support::generate_storage_alias;
+/// # use frame_support::storage_alias;
 /// use frame_support::codec;
 /// use frame_support::Twox64Concat;
 /// // generate a storage value with type u32.
-/// generate_storage_alias!(Prefix, StorageName => Value<u32>);
+/// #[storage_alias]
+/// type StorageName = Value<Prefix, u32>;
 ///
 /// // generate a double map from `(u32, u32)` (with hashers `Twox64Concat` for each key)
 /// // to `Vec<u8>`
-/// generate_storage_alias!(
-/// 	OtherPrefix, OtherStorageName => DoubleMap<
-/// 		(Twox64Concat, u32),
-/// 		(Twox64Concat, u32),
-/// 		Vec<u8>
-/// 	>
-/// );
+/// #[storage_alias]
+/// type OtherStorageName = DoubleMap<
+/// 	OtherPrefix,
+/// 	Twox64Concat,
+/// 	u32,
+/// 	Twox64Concat,
+/// 	u32,
+/// 	Vec<u8>,
+/// >;
 ///
 /// // optionally specify the query type
 /// use frame_support::pallet_prelude::{ValueQuery, OptionQuery};
-/// generate_storage_alias!(Prefix, ValueName => Value<u32, OptionQuery>);
-/// generate_storage_alias!(
-/// 	Prefix, SomeStorageName => DoubleMap<
-/// 		(Twox64Concat, u32),
-/// 		(Twox64Concat, u32),
-/// 		Vec<u8>,
-/// 		ValueQuery
-/// 	>
-/// );
+/// #[storage_alias]
+/// type ValueName = Value<Prefix, u32, OptionQuery>;
+/// #[storage_alias]
+/// type SomeStorageName = Map<
+/// 	Prefix,
+/// 	Twox64Concat,
+/// 	u32,
+/// 	Vec<u8>,
+/// 	ValueQuery,
+/// >;
 ///
 /// // generate a map from `Config::AccountId` (with hasher `Twox64Concat`) to `Vec<u8>`
 /// trait Config { type AccountId: codec::FullCodec; }
-/// generate_storage_alias!(
-/// 	Prefix, GenericStorage<T: Config> => Map<(Twox64Concat, T::AccountId), Vec<u8>>
-/// );
+/// #[storage_alias]
+/// type GenericStorage<T> = Map<Prefix, Twox64Concat, <T as Config>::AccountId, Vec<u8>>;
+///
+/// // It also supports NMap
+/// use frame_support::storage::types::Key as NMapKey;
+///
+/// #[storage_alias]
+/// type SomeNMap = NMap<Prefix, (NMapKey<Twox64Concat, u32>, NMapKey<Twox64Concat, u64>), Vec<u8>>;
+///
+/// // Using pallet name as prefix.
+/// //
+/// // When the first generic argument is taking generic arguments it is expected to be a pallet.
+/// // The prefix will then be the pallet name as configured in the runtime through
+/// // `construct_runtime!`.
+///
+/// # struct Pallet<T: Config>(std::marker::PhantomData<T>);
+/// # impl<T: Config> frame_support::traits::PalletInfoAccess for Pallet<T> {
+/// # 	fn index() -> usize { 0 }
+/// # 	fn name() -> &'static str { "pallet" }
+/// # 	fn module_name() -> &'static str { "module" }
+/// # 	fn crate_version() -> frame_support::traits::CrateVersion { unimplemented!() }
+/// # }
+///
+/// #[storage_alias]
+/// type SomeValue<T> = Value<Pallet<T: Config>, u64>;
+///
 /// # fn main() {}
 /// ```
-#[macro_export]
-macro_rules! generate_storage_alias {
-	// without generic for $name.
-	($pallet:ident, $name:ident => Map<($hasher:ty, $key:ty), $value:ty $(, $querytype:ty)?>) => {
-		$crate::paste::paste! {
-			$crate::generate_storage_alias!(@GENERATE_INSTANCE_STRUCT $pallet, $name);
-			type $name = $crate::storage::types::StorageMap<
-				[<$name Instance>],
-				$hasher,
-				$key,
-				$value,
-				$( $querytype )?
-			>;
-		}
-	};
-	(
-		$pallet:ident,
-		$name:ident
-		=> DoubleMap<($hasher1:ty, $key1:ty), ($hasher2:ty, $key2:ty), $value:ty $(, $querytype:ty)?>
-	) => {
-		$crate::paste::paste! {
-			$crate::generate_storage_alias!(@GENERATE_INSTANCE_STRUCT $pallet, $name);
-			type $name = $crate::storage::types::StorageDoubleMap<
-				[<$name Instance>],
-				$hasher1,
-				$key1,
-				$hasher2,
-				$key2,
-				$value,
-				$( $querytype )?
-			>;
-		}
-	};
-	(
-		$pallet:ident,
-		$name:ident
-		=> NMap<Key<$(($hasher:ty, $key:ty)),+>, $value:ty $(, $querytype:ty)?>
-	) => {
-		$crate::paste::paste! {
-			$crate::generate_storage_alias!(@GENERATE_INSTANCE_STRUCT $pallet, $name);
-			type $name = $crate::storage::types::StorageNMap<
-				[<$name Instance>],
-				(
-					$( $crate::storage::types::Key<$hasher, $key>, )+
-				),
-				$value,
-				$( $querytype )?
-			>;
-		}
-	};
-	($pallet:ident, $name:ident => Value<$value:ty $(, $querytype:ty)?>) => {
-		$crate::paste::paste! {
-			$crate::generate_storage_alias!(@GENERATE_INSTANCE_STRUCT $pallet, $name);
-			type $name = $crate::storage::types::StorageValue<
-				[<$name Instance>],
-				$value,
-				$( $querytype )?
-			>;
-		}
-	};
-	// with generic for $name.
-	(
-		$pallet:ident,
-		$name:ident<$t:ident : $bounds:tt>
-		=> Map<($hasher:ty, $key:ty), $value:ty $(, $querytype:ty)?>
-	) => {
-		$crate::paste::paste! {
-			$crate::generate_storage_alias!(@GENERATE_INSTANCE_STRUCT $pallet, $name);
-			#[allow(type_alias_bounds)]
-			type $name<$t : $bounds> = $crate::storage::types::StorageMap<
-				[<$name Instance>],
-				$hasher,
-				$key,
-				$value,
-				$( $querytype )?
-			>;
-		}
-	};
-	(
-		$pallet:ident,
-		$name:ident<$t:ident : $bounds:tt>
-		=> DoubleMap<($hasher1:ty, $key1:ty), ($hasher2:ty, $key2:ty), $value:ty $(, $querytype:ty)?>
-	) => {
-		$crate::paste::paste! {
-			$crate::generate_storage_alias!(@GENERATE_INSTANCE_STRUCT $pallet, $name);
-			#[allow(type_alias_bounds)]
-			type $name<$t : $bounds> = $crate::storage::types::StorageDoubleMap<
-				[<$name Instance>],
-				$hasher1,
-				$key1,
-				$hasher2,
-				$key2,
-				$value,
-				$( $querytype )?
-			>;
-		}
-	};
-	(
-		$pallet:ident,
-		$name:ident<$t:ident : $bounds:tt>
-		=> NMap<$(($hasher:ty, $key:ty),)+ $value:ty $(, $querytype:ty)?>
-	) => {
-		$crate::paste::paste! {
-			$crate::generate_storage_alias!(@GENERATE_INSTANCE_STRUCT $pallet, $name);
-			#[allow(type_alias_bounds)]
-			type $name<$t : $bounds> = $crate::storage::types::StorageNMap<
-				[<$name Instance>],
-				(
-					$( $crate::storage::types::Key<$hasher, $key>, )+
-				),
-				$value,
-				$( $querytype )?
-			>;
-		}
-	};
-	($pallet:ident, $name:ident<$t:ident : $bounds:tt> => Value<$value:ty $(, $querytype:ty)?>) => {
-		$crate::paste::paste! {
-			$crate::generate_storage_alias!(@GENERATE_INSTANCE_STRUCT $pallet, $name);
-			#[allow(type_alias_bounds)]
-			type $name<$t : $bounds> = $crate::storage::types::StorageValue<
-				[<$name Instance>],
-				$value,
-				$( $querytype )?
-			>;
-		}
-	};
-	// helper used in all arms.
-	(@GENERATE_INSTANCE_STRUCT $pallet:ident, $name:ident) => {
-		$crate::paste::paste! {
-			struct [<$name Instance>];
-			impl $crate::traits::StorageInstance for [<$name Instance>] {
-				fn pallet_prefix() -> &'static str { stringify!($pallet) }
-				const STORAGE_PREFIX: &'static str = stringify!($name);
-			}
-		}
-	};
-}
+pub use frame_support_procedural::storage_alias;
 
 /// Create new implementations of the [`Get`](crate::traits::Get) trait.
 ///
@@ -995,16 +886,20 @@ pub mod tests {
 	}
 
 	#[test]
-	fn generate_storage_alias_works() {
+	fn storage_alias_works() {
 		new_test_ext().execute_with(|| {
-			generate_storage_alias!(
-				Test,
-				GenericData2<T: Config> => Map<(Blake2_128Concat, T::BlockNumber), T::BlockNumber>
-			);
+			#[crate::storage_alias]
+			type GenericData2<T> =
+				Map<Test, Blake2_128Concat, <T as Config>::BlockNumber, <T as Config>::BlockNumber>;
 
 			assert_eq!(Module::<Test>::generic_data2(5), None);
 			GenericData2::<Test>::insert(5, 5);
 			assert_eq!(Module::<Test>::generic_data2(5), Some(5));
+
+			/// Some random docs that ensure that docs are accepted
+			#[crate::storage_alias]
+			pub type GenericData<T> =
+				Map<Test2, Blake2_128Concat, <T as Config>::BlockNumber, <T as Config>::BlockNumber>;
 		});
 	}
 
diff --git a/frame/support/src/storage/bounded_btree_map.rs b/frame/support/src/storage/bounded_btree_map.rs
index 0d589994bcc2c..df7abebe1956b 100644
--- a/frame/support/src/storage/bounded_btree_map.rs
+++ b/frame/support/src/storage/bounded_btree_map.rs
@@ -348,12 +348,14 @@ pub mod test {
 	use frame_support::traits::ConstU32;
 	use sp_io::TestExternalities;
 
-	crate::generate_storage_alias! { Prefix, Foo => Value<BoundedBTreeMap<u32, (), ConstU32<7>>> }
-	crate::generate_storage_alias! { Prefix, FooMap => Map<(Twox128, u32), BoundedBTreeMap<u32, (),  ConstU32<7>>> }
-	crate::generate_storage_alias! {
-		Prefix,
-		FooDoubleMap => DoubleMap<(Twox128, u32), (Twox128, u32), BoundedBTreeMap<u32, (),  ConstU32<7>>>
-	}
+	#[crate::storage_alias]
+	type Foo = Value<Prefix, BoundedBTreeMap<u32, (), ConstU32<7>>>;
+
+	#[crate::storage_alias]
+	type FooMap = Map<Prefix, Twox128, u32, BoundedBTreeMap<u32, (), ConstU32<7>>>;
+
+	#[crate::storage_alias]
+	type FooDoubleMap = DoubleMap<Prefix, Twox128, u32, Twox128, u32, BoundedBTreeMap<u32, (), ConstU32<7>>>;
 
 	fn map_from_keys<K>(keys: &[K]) -> BTreeMap<K, ()>
 	where
diff --git a/frame/support/src/storage/bounded_btree_set.rs b/frame/support/src/storage/bounded_btree_set.rs
index f38952bf545d9..f674c9b2c0bf3 100644
--- a/frame/support/src/storage/bounded_btree_set.rs
+++ b/frame/support/src/storage/bounded_btree_set.rs
@@ -322,12 +322,15 @@ pub mod test {
 	use frame_support::traits::ConstU32;
 	use sp_io::TestExternalities;
 
-	crate::generate_storage_alias! { Prefix, Foo => Value<BoundedBTreeSet<u32, ConstU32<7>>> }
-	crate::generate_storage_alias! { Prefix, FooMap => Map<(Twox128, u32), BoundedBTreeSet<u32, ConstU32<7>>> }
-	crate::generate_storage_alias! {
-		Prefix,
-		FooDoubleMap => DoubleMap<(Twox128, u32), (Twox128, u32), BoundedBTreeSet<u32, ConstU32<7>>>
-	}
+	#[crate::storage_alias]
+	type Foo = Value<Prefix, BoundedBTreeSet<u32, ConstU32<7>>>;
+
+	#[crate::storage_alias]
+	type FooMap = Map<Prefix, Twox128, u32, BoundedBTreeSet<u32, ConstU32<7>>>;
+
+	#[crate::storage_alias]
+	type FooDoubleMap =
+		DoubleMap<Prefix, Twox128, u32, Twox128, u32, BoundedBTreeSet<u32, ConstU32<7>>>;
 
 	fn set_from_keys<T>(keys: &[T]) -> BTreeSet<T>
 	where
diff --git a/frame/support/src/storage/bounded_vec.rs b/frame/support/src/storage/bounded_vec.rs
index 92ca167f98436..2024d99771b3d 100644
--- a/frame/support/src/storage/bounded_vec.rs
+++ b/frame/support/src/storage/bounded_vec.rs
@@ -609,12 +609,14 @@ pub mod test {
 	use crate::{bounded_vec, traits::ConstU32, Twox128};
 	use sp_io::TestExternalities;
 
-	crate::generate_storage_alias! { Prefix, Foo => Value<BoundedVec<u32, ConstU32<7>>> }
-	crate::generate_storage_alias! { Prefix, FooMap => Map<(Twox128, u32), BoundedVec<u32, ConstU32<7>>> }
-	crate::generate_storage_alias! {
-		Prefix,
-		FooDoubleMap => DoubleMap<(Twox128, u32), (Twox128, u32), BoundedVec<u32, ConstU32<7>>>
-	}
+	#[crate::storage_alias]
+	type Foo = Value<Prefix, BoundedVec<u32, ConstU32<7>>>;
+
+	#[crate::storage_alias]
+	type FooMap = Map<Prefix, Twox128, u32, BoundedVec<u32, ConstU32<7>>>;
+
+	#[crate::storage_alias]
+	type FooDoubleMap = DoubleMap<Prefix, Twox128, u32, Twox128, u32, BoundedVec<u32, ConstU32<7>>>;
 
 	#[test]
 	fn slide_works() {
diff --git a/frame/support/src/storage/generator/double_map.rs b/frame/support/src/storage/generator/double_map.rs
index 16fcaf940c62a..6264738265678 100644
--- a/frame/support/src/storage/generator/double_map.rs
+++ b/frame/support/src/storage/generator/double_map.rs
@@ -525,10 +525,8 @@ mod test_iterators {
 	fn double_map_iter_from() {
 		sp_io::TestExternalities::default().execute_with(|| {
 			use crate::hash::Identity;
-			crate::generate_storage_alias!(
-				MyModule,
-				MyDoubleMap => DoubleMap<(Identity, u64), (Identity, u64), u64>
-			);
+			#[crate::storage_alias]
+			type MyDoubleMap = DoubleMap<MyModule, Identity, u64, Identity, u64, u64>;
 
 			MyDoubleMap::insert(1, 10, 100);
 			MyDoubleMap::insert(1, 21, 201);
diff --git a/frame/support/src/storage/generator/map.rs b/frame/support/src/storage/generator/map.rs
index da48952bcba87..f054c5c36b84a 100644
--- a/frame/support/src/storage/generator/map.rs
+++ b/frame/support/src/storage/generator/map.rs
@@ -384,7 +384,8 @@ mod test_iterators {
 	fn map_iter_from() {
 		sp_io::TestExternalities::default().execute_with(|| {
 			use crate::hash::Identity;
-			crate::generate_storage_alias!(MyModule, MyMap => Map<(Identity, u64), u64>);
+			#[crate::storage_alias]
+			type MyMap = Map<MyModule, Identity, u64, u64>;
 
 			MyMap::insert(1, 10);
 			MyMap::insert(2, 20);
diff --git a/frame/support/src/storage/generator/nmap.rs b/frame/support/src/storage/generator/nmap.rs
index be085ca2d9db6..ef243cead7580 100755
--- a/frame/support/src/storage/generator/nmap.rs
+++ b/frame/support/src/storage/generator/nmap.rs
@@ -475,10 +475,12 @@ mod test_iterators {
 	fn n_map_iter_from() {
 		sp_io::TestExternalities::default().execute_with(|| {
 			use crate::{hash::Identity, storage::Key as NMapKey};
-			crate::generate_storage_alias!(
+			#[crate::storage_alias]
+			type MyNMap = NMap<
 				MyModule,
-				MyNMap => NMap<Key<(Identity, u64), (Identity, u64), (Identity, u64)>, u64>
-			);
+				(NMapKey<Identity, u64>, NMapKey<Identity, u64>, NMapKey<Identity, u64>),
+				u64,
+			>;
 
 			MyNMap::insert((1, 1, 1), 11);
 			MyNMap::insert((1, 1, 2), 21);
@@ -518,11 +520,9 @@ mod test_iterators {
 			let key_hash = NMap::hashed_key_for((1, 2));
 
 			{
-				crate::generate_storage_alias!(Test, NMap => DoubleMap<
-					(crate::Blake2_128Concat, u16),
-					(crate::Twox64Concat, u32),
-					u64
-				>);
+				#[crate::storage_alias]
+				type NMap =
+					DoubleMap<Test, crate::Blake2_128Concat, u16, crate::Twox64Concat, u32, u64>;
 
 				let value = NMap::get(1, 2).unwrap();
 				assert_eq!(value, 50);
diff --git a/frame/support/src/storage/mod.rs b/frame/support/src/storage/mod.rs
index 115f179d803a7..d181ba12ca869 100644
--- a/frame/support/src/storage/mod.rs
+++ b/frame/support/src/storage/mod.rs
@@ -1545,10 +1545,8 @@ mod test {
 	fn prefix_iterator_pagination_works() {
 		TestExternalities::default().execute_with(|| {
 			use crate::{hash::Identity, storage::generator::map::StorageMap};
-			crate::generate_storage_alias! {
-				MyModule,
-				MyStorageMap => Map<(Identity, u64), u64>
-			}
+			#[crate::storage_alias]
+			type MyStorageMap = Map<MyModule, Identity, u64, u64>;
 
 			MyStorageMap::insert(1, 10);
 			MyStorageMap::insert(2, 20);
@@ -1663,12 +1661,12 @@ mod test {
 		});
 	}
 
-	crate::generate_storage_alias! { Prefix, Foo => Value<WeakBoundedVec<u32, ConstU32<7>>> }
-	crate::generate_storage_alias! { Prefix, FooMap => Map<(Twox128, u32), BoundedVec<u32, ConstU32<7>>> }
-	crate::generate_storage_alias! {
-		Prefix,
-		FooDoubleMap => DoubleMap<(Twox128, u32), (Twox128, u32), BoundedVec<u32, ConstU32<7>>>
-	}
+	#[crate::storage_alias]
+	type Foo = Value<Prefix, WeakBoundedVec<u32, ConstU32<7>>>;
+	#[crate::storage_alias]
+	type FooMap = Map<Prefix, Twox128, u32, BoundedVec<u32, ConstU32<7>>>;
+	#[crate::storage_alias]
+	type FooDoubleMap = DoubleMap<Prefix, Twox128, u32, Twox128, u32, BoundedVec<u32, ConstU32<7>>>;
 
 	#[test]
 	fn try_append_works() {
diff --git a/frame/support/src/storage/types/nmap.rs b/frame/support/src/storage/types/nmap.rs
index 16dc30ea03903..349d9eea3bede 100755
--- a/frame/support/src/storage/types/nmap.rs
+++ b/frame/support/src/storage/types/nmap.rs
@@ -544,7 +544,7 @@ mod test {
 	use crate::{
 		hash::{StorageHasher as _, *},
 		metadata::{StorageEntryModifier, StorageHasher},
-		storage::types::{Key, ValueQuery},
+		storage::types::{Key, Key as NMapKey, ValueQuery},
 	};
 	use sp_io::{hashing::twox_128, TestExternalities};
 
@@ -589,10 +589,8 @@ mod test {
 			assert_eq!(AValueQueryWithAnOnEmpty::get((3,)), 10);
 
 			{
-				crate::generate_storage_alias!(test, Foo => NMap<
-					Key<(Blake2_128Concat, u16)>,
-					u32
-				>);
+				#[crate::storage_alias]
+				type Foo = NMap<test, (NMapKey<Blake2_128Concat, u16>), u32>;
 
 				assert_eq!(Foo::contains_key((3,)), true);
 				assert_eq!(Foo::get((3,)), Some(10));
diff --git a/frame/support/src/storage/weak_bounded_vec.rs b/frame/support/src/storage/weak_bounded_vec.rs
index 21cc487b49082..ddbde380147db 100644
--- a/frame/support/src/storage/weak_bounded_vec.rs
+++ b/frame/support/src/storage/weak_bounded_vec.rs
@@ -321,12 +321,13 @@ pub mod test {
 	use frame_support::traits::ConstU32;
 	use sp_io::TestExternalities;
 
-	crate::generate_storage_alias! { Prefix, Foo => Value<WeakBoundedVec<u32, ConstU32<7>>> }
-	crate::generate_storage_alias! { Prefix, FooMap => Map<(Twox128, u32), WeakBoundedVec<u32, ConstU32<7>>> }
-	crate::generate_storage_alias! {
-		Prefix,
-		FooDoubleMap => DoubleMap<(Twox128, u32), (Twox128, u32), WeakBoundedVec<u32, ConstU32<7>>>
-	}
+	#[crate::storage_alias]
+	type Foo = Value<Prefix, WeakBoundedVec<u32, ConstU32<7>>>;
+	#[crate::storage_alias]
+	type FooMap = Map<Prefix, Twox128, u32, WeakBoundedVec<u32, ConstU32<7>>>;
+	#[crate::storage_alias]
+	type FooDoubleMap =
+		DoubleMap<Prefix, Twox128, u32, Twox128, u32, WeakBoundedVec<u32, ConstU32<7>>>;
 
 	#[test]
 	fn bound_returns_correct_value() {
diff --git a/frame/system/src/migrations/mod.rs b/frame/system/src/migrations/mod.rs
index 872cf389d246c..7e1e2ab05ffcf 100644
--- a/frame/system/src/migrations/mod.rs
+++ b/frame/system/src/migrations/mod.rs
@@ -17,6 +17,7 @@
 
 //! Migrate the reference counting state.
 
+use crate::{Config, Pallet};
 use codec::{Decode, Encode, FullCodec};
 use frame_support::{
 	pallet_prelude::ValueQuery, traits::PalletInfoAccess, weights::Weight, Blake2_128Concat,
@@ -52,43 +53,24 @@ pub trait V2ToV3 {
 	type AccountData: 'static + FullCodec;
 }
 
-// ### Warning
-//
-// The call below is only valid because the name System is enforced
-// at runtime construction level for the system pallet.
-frame_support::generate_storage_alias!(
-	System, UpgradedToU32RefCount => Value<
-		bool,
-		ValueQuery
-	>
-);
-
-// ### Warning
-//
-// The call below is only valid because the name System is enforced
-// at runtime construction level for the system pallet.
-frame_support::generate_storage_alias!(
-	System, UpgradedToTripleRefCount => Value<
-		bool,
-		ValueQuery
-	>
-);
-
-// ### Warning
-//
-// The call below is only valid because the name System is enforced
-// at runtime construction level for the system pallet.
-frame_support::generate_storage_alias!(
-	System, Account<T: V2ToV3> => Map<
-		(Blake2_128Concat, T::AccountId),
-		AccountInfo<T::Index, T::AccountData>
-	>
-);
+#[frame_support::storage_alias]
+type UpgradedToU32RefCount<T> = Value<Pallet<T: Config>, bool, ValueQuery>;
+
+#[frame_support::storage_alias]
+type UpgradedToTripleRefCount<T> = Value<Pallet<T: Config>, bool, ValueQuery>;
+
+#[frame_support::storage_alias]
+type Account<V, T> = Map<
+	Pallet<T: Config>,
+	Blake2_128Concat,
+	<V as V2ToV3>::AccountId,
+	AccountInfo<<V as V2ToV3>::Index, <V as V2ToV3>::AccountData>,
+>;
 
 /// Migrate from unique `u8` reference counting to triple `u32` reference counting.
-pub fn migrate_from_single_u8_to_triple_ref_count<T: V2ToV3>() -> Weight {
+pub fn migrate_from_single_u8_to_triple_ref_count<V: V2ToV3, T: Config>() -> Weight {
 	let mut translated: usize = 0;
-	<Account<T>>::translate::<(T::Index, u8, T::AccountData), _>(|_key, (nonce, rc, data)| {
+	<Account<V, T>>::translate::<(V::Index, u8, V::AccountData), _>(|_key, (nonce, rc, data)| {
 		translated += 1;
 		Some(AccountInfo { nonce, consumers: rc as RefCount, providers: 1, sufficients: 0, data })
 	});
@@ -97,15 +79,15 @@ pub fn migrate_from_single_u8_to_triple_ref_count<T: V2ToV3>() -> Weight {
 		"Applied migration from single u8 to triple reference counting to {:?} elements.",
 		translated
 	);
-	<UpgradedToU32RefCount>::put(true);
-	<UpgradedToTripleRefCount>::put(true);
+	<UpgradedToU32RefCount<T>>::put(true);
+	<UpgradedToTripleRefCount<T>>::put(true);
 	Weight::max_value()
 }
 
 /// Migrate from unique `u32` reference counting to triple `u32` reference counting.
-pub fn migrate_from_single_to_triple_ref_count<T: V2ToV3>() -> Weight {
+pub fn migrate_from_single_to_triple_ref_count<V: V2ToV3, T: Config>() -> Weight {
 	let mut translated: usize = 0;
-	<Account<T>>::translate::<(T::Index, RefCount, T::AccountData), _>(
+	<Account<V, T>>::translate::<(V::Index, RefCount, V::AccountData), _>(
 		|_key, (nonce, consumers, data)| {
 			translated += 1;
 			Some(AccountInfo { nonce, consumers, providers: 1, sufficients: 0, data })
@@ -116,14 +98,14 @@ pub fn migrate_from_single_to_triple_ref_count<T: V2ToV3>() -> Weight {
 		"Applied migration from single to triple reference counting to {:?} elements.",
 		translated
 	);
-	<UpgradedToTripleRefCount>::put(true);
+	<UpgradedToTripleRefCount<T>>::put(true);
 	Weight::max_value()
 }
 
 /// Migrate from dual `u32` reference counting to triple `u32` reference counting.
-pub fn migrate_from_dual_to_triple_ref_count<T: V2ToV3>() -> Weight {
+pub fn migrate_from_dual_to_triple_ref_count<V: V2ToV3, T: Config>() -> Weight {
 	let mut translated: usize = 0;
-	<Account<T>>::translate::<(T::Index, RefCount, RefCount, T::AccountData), _>(
+	<Account<V, T>>::translate::<(V::Index, RefCount, RefCount, V::AccountData), _>(
 		|_key, (nonce, consumers, providers, data)| {
 			translated += 1;
 			Some(AccountInfo { nonce, consumers, providers, sufficients: 0, data })
@@ -134,6 +116,6 @@ pub fn migrate_from_dual_to_triple_ref_count<T: V2ToV3>() -> Weight {
 		"Applied migration from dual to triple reference counting to {:?} elements.",
 		translated
 	);
-	<UpgradedToTripleRefCount>::put(true);
+	<UpgradedToTripleRefCount<T>>::put(true);
 	Weight::max_value()
 }

From 43cf8c13eb4cf3b16bd1d7feafa219e76c3bf97c Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@parity.io>
Date: Tue, 10 May 2022 14:00:07 +0100
Subject: [PATCH 16/43] Maintenance operations don't pay fee

---
 frame/society/src/lib.rs | 41 ++++++++++++++++++++++++++--------------
 1 file changed, 27 insertions(+), 14 deletions(-)

diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index 48ed6da71ac70..74cea2f3e6e84 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -469,6 +469,8 @@ pub enum OldVote {
 
 #[frame_support::pallet]
 pub mod pallet {
+	use frame_support::dispatch::PaysFee;
+
 	use super::*;
 
 	#[pallet::pallet]
@@ -1004,13 +1006,15 @@ pub mod pallet {
 			let mut candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
 			let record = Members::<T, I>::get(&voter).ok_or(Error::<T, I>::NotMember)?;
 
-			Votes::<T, I>::mutate(&candidate, &voter, |v| {
+			let first_time = Votes::<T, I>::mutate(&candidate, &voter, |v| {
+				let first_time = v.is_none();
 				*v = Some(Self::do_vote(*v, approve, record.rank, &mut candidacy.tally));
+				first_time
 			});
 
 			Candidates::<T, I>::insert(&candidate, &candidacy);
 			Self::deposit_event(Event::<T, I>::Vote { candidate, voter, vote: approve });
-			Ok(())
+			Ok(if first_time { Pays::No } else { Pays::Yes }.into())
 		}
 
 		/// As a member, vote on the defender.
@@ -1031,13 +1035,15 @@ pub mod pallet {
 			let mut defending = Defending::<T, I>::get().ok_or(Error::<T, I>::NoDefender)?;
 			let record = Members::<T, I>::get(&voter).ok_or(Error::<T, I>::NotMember)?;
 
-			DefenderVotes::<T, I>::mutate(&voter, |v| {
+			let first_time = DefenderVotes::<T, I>::mutate(&voter, |v| {
+				let first_time = v.is_none();
 				*v = Some(Self::do_vote(*v, approve, record.rank, &mut defending.2));
+				first_time
 			});
 
 			Defending::<T, I>::put(defending);
 			Self::deposit_event(Event::<T, I>::DefenderVote { voter, vote: approve });
-			Ok(())
+			Ok(if first_time { Pays::No } else { Pays::Yes }.into())
 		}
 
 		/// Transfer the first matured payout for the sender and remove it from the records.
@@ -1199,7 +1205,7 @@ pub mod pallet {
 
 			SuspendedMembers::<T, I>::remove(&who);
 			Self::deposit_event(Event::<T, I>::SuspendedMemberJudgement { who, judged: forgive });
-			Ok(())
+			Ok(Pays::No)
 		}
 
 		/// Change the maximum number of members in society and the maximum number of new candidates
@@ -1240,9 +1246,9 @@ pub mod pallet {
 			let mut candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
 			ensure!(!candidacy.skeptic_struck, Error::<T, I>::AlreadyPunished);
 			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
-			Self::check_skeptic(&candidate, &mut candidacy);
+			let punished = Self::check_skeptic(&candidate, &mut candidacy);
 			Candidates::<T, I>::insert(&candidate, candidacy);
-			Ok(())
+			Ok(if punished { Pays::No } else { Pays::Yes }.into())
 		}
 
 		/// Transform an approved candidate into a member. Callable only by the
@@ -1253,7 +1259,8 @@ pub mod pallet {
 			let candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
 			ensure!(candidacy.tally.clear_approval(), Error::<T, I>::NotApproved);
 			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
-			Self::induct_member(candidate, candidacy, 0)
+			Self::induct_member(candidate, candidacy, 0)?;
+			Ok(Pays::No.into())
 		}
 
 		/// Transform an approved candidate into a member. Callable only by the Signed origin of the
@@ -1266,7 +1273,8 @@ pub mod pallet {
 			let candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
 			ensure!(!candidacy.tally.clear_rejection(), Error::<T, I>::Rejected);
 			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
-			Self::induct_member(candidate, candidacy, 0)
+			Self::induct_member(candidate, candidacy, 0)?;
+			Ok(Pays::No.into())
 		}
 
 		/// Remove the candidate's application from the society. Callable only by the Signed origin
@@ -1285,7 +1293,7 @@ pub mod pallet {
 			Self::reject_candidate(&candidate, &candidacy.kind);
 			Votes::<T, I>::remove_prefix(&candidate, None);
 			Candidates::<T, I>::remove(&candidate);
-			Ok(())
+			Ok(Pays::No)
 		}
 
 		/// Remove the candidate's application from the society. Callable only by the candidate.
@@ -1301,7 +1309,7 @@ pub mod pallet {
 			Self::reject_candidate(&candidate, &candidacy.kind);
 			Votes::<T, I>::remove_prefix(&candidate, None);
 			Candidates::<T, I>::remove(&candidate);
-			Ok(())
+			Ok(Pays::No)
 		}
 
 		/// Remove a `candidate`'s failed application from the society. Callable by any
@@ -1318,7 +1326,7 @@ pub mod pallet {
 			Self::reject_candidate(&candidate, &candidacy.kind);
 			Votes::<T, I>::remove_prefix(&candidate, None);
 			Candidates::<T, I>::remove(&candidate);
-			Ok(())
+			Ok(Pays::No)
 		}
 	}
 }
@@ -1379,6 +1387,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		target_round == round && matches!(Self::period(), Period::Voting {..})
 	}
 
+	/// Returns the new vote.
 	fn do_vote(maybe_old: Option<Vote>, approve: bool, rank: Rank, tally: &mut Tally) -> Vote {
 		match maybe_old {
 			Some(Vote { approve: true, weight }) => tally.approvals.saturating_reduce(weight),
@@ -1394,7 +1403,8 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		Vote { approve, weight }
 	}
 
-	fn check_skeptic(candidate: &T::AccountId, candidacy: &mut Candidacy<T::AccountId, BalanceOf<T, I>>) {
+	/// Returns `true` if a punishment was given.
+	fn check_skeptic(candidate: &T::AccountId, candidacy: &mut Candidacy<T::AccountId, BalanceOf<T, I>>) -> bool {
 		if RoundCount::<T, I>::get() != candidacy.round || candidacy.skeptic_struck { return }
 		// We expect the skeptic to have voted.
 		let skeptic = match Skeptic::<T, I>::get() { Some(s) => s, None => return };
@@ -1409,9 +1419,12 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 				// Can't do much if the punishment doesn't work out.
 				if Self::strike_member(&skeptic).is_ok() {
 					candidacy.skeptic_struck = true;
+					true
+				} else {
+					false
 				}
 			},
-			_ => {},
+			_ => false,
 		}
 	}
 

From b12cbb2cd29c0f0a8b3b19f1ee3df8193fc0d44a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bastian=20K=C3=B6cher?= <info@kchr.de>
Date: Tue, 10 May 2022 17:04:12 +0200
Subject: [PATCH 17/43] Fix compilation and FMT

---
 frame/offences/src/migration.rs               |  4 +---
 frame/support/procedural/src/lib.rs           |  2 +-
 frame/support/procedural/src/storage_alias.rs | 22 +++++++++----------
 frame/support/src/lib.rs                      |  8 +++++--
 .../support/src/storage/bounded_btree_map.rs  |  3 ++-
 5 files changed, 21 insertions(+), 18 deletions(-)

diff --git a/frame/offences/src/migration.rs b/frame/offences/src/migration.rs
index 72178fe389568..9b883b2809138 100644
--- a/frame/offences/src/migration.rs
+++ b/frame/offences/src/migration.rs
@@ -16,9 +16,7 @@
 // limitations under the License.
 
 use super::{Config, OffenceDetails, Perbill, SessionIndex};
-use frame_support::{
-	storage_alias, pallet_prelude::ValueQuery, traits::Get, weights::Weight,
-};
+use frame_support::{pallet_prelude::ValueQuery, storage_alias, traits::Get, weights::Weight};
 use sp_staking::offence::{DisableStrategy, OnOffenceHandler};
 use sp_std::vec::Vec;
 
diff --git a/frame/support/procedural/src/lib.rs b/frame/support/procedural/src/lib.rs
index f4e64cb949aa9..f8aaa5fe37749 100644
--- a/frame/support/procedural/src/lib.rs
+++ b/frame/support/procedural/src/lib.rs
@@ -25,13 +25,13 @@ mod crate_version;
 mod debug_no_bound;
 mod default_no_bound;
 mod dummy_part_checker;
-mod storage_alias;
 mod key_prefix;
 mod match_and_insert;
 mod pallet;
 mod pallet_error;
 mod partial_eq_no_bound;
 mod storage;
+mod storage_alias;
 mod transactional;
 mod tt_macro;
 
diff --git a/frame/support/procedural/src/storage_alias.rs b/frame/support/procedural/src/storage_alias.rs
index 39760661dd911..6fe98700385de 100644
--- a/frame/support/procedural/src/storage_alias.rs
+++ b/frame/support/procedural/src/storage_alias.rs
@@ -302,7 +302,17 @@ impl Parse for StorageType {
 		let parse_pallet_generics = |input: ParseStream<'_>| -> Result<Option<SimpleGenerics>> {
 			let lookahead = input.lookahead1();
 			if lookahead.peek(Token![<]) {
-				Some(input.parse()).transpose()
+				let generics = input.parse::<SimpleGenerics>()?;
+
+				if generics.all_have_trait_bounds() {
+					Ok(Some(generics))
+				} else {
+					Err(Error::new_spanned(
+						generics,
+						"The pallet generics require to be bound by the \
+						pallet `Config` trait and optional `Instance` trait.",
+					))
+				}
 			} else if lookahead.peek(Token![,]) {
 				Ok(None)
 			} else {
@@ -430,16 +440,6 @@ pub fn storage_alias(input: TokenStream) -> Result<TokenStream> {
 	let input = syn::parse2::<Input>(input)?;
 	let crate_ = generate_crate_access_2018("frame-support")?;
 
-	if let Some(ref generics) = input.storage_generics {
-		if !generics.all_have_trait_bounds() {
-			return Err(Error::new_spanned(
-				generics,
-				"The pallet generics require to be bound by the \
-				 pallet `Config` trait and optional `Instance` trait.",
-			))
-		}
-	}
-
 	let storage_instance = generate_storage_instance(
 		&crate_,
 		&input.storage_name,
diff --git a/frame/support/src/lib.rs b/frame/support/src/lib.rs
index 4cd740c52162a..0453c5339f80d 100644
--- a/frame/support/src/lib.rs
+++ b/frame/support/src/lib.rs
@@ -898,8 +898,12 @@ pub mod tests {
 
 			/// Some random docs that ensure that docs are accepted
 			#[crate::storage_alias]
-			pub type GenericData<T> =
-				Map<Test2, Blake2_128Concat, <T as Config>::BlockNumber, <T as Config>::BlockNumber>;
+			pub type GenericData<T> = Map<
+				Test2,
+				Blake2_128Concat,
+				<T as Config>::BlockNumber,
+				<T as Config>::BlockNumber,
+			>;
 		});
 	}
 
diff --git a/frame/support/src/storage/bounded_btree_map.rs b/frame/support/src/storage/bounded_btree_map.rs
index df7abebe1956b..6afc786aeb987 100644
--- a/frame/support/src/storage/bounded_btree_map.rs
+++ b/frame/support/src/storage/bounded_btree_map.rs
@@ -355,7 +355,8 @@ pub mod test {
 	type FooMap = Map<Prefix, Twox128, u32, BoundedBTreeMap<u32, (), ConstU32<7>>>;
 
 	#[crate::storage_alias]
-	type FooDoubleMap = DoubleMap<Prefix, Twox128, u32, Twox128, u32, BoundedBTreeMap<u32, (), ConstU32<7>>>;
+	type FooDoubleMap =
+		DoubleMap<Prefix, Twox128, u32, Twox128, u32, BoundedBTreeMap<u32, (), ConstU32<7>>>;
 
 	fn map_from_keys<K>(keys: &[K]) -> BTreeMap<K, ()>
 	where

From 249b664bf5d1e6e61dbecf6431f0be08b37afa27 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bastian=20K=C3=B6cher?= <info@kchr.de>
Date: Tue, 10 May 2022 17:30:45 +0200
Subject: [PATCH 18/43] Moare fixes

---
 frame/elections-phragmen/src/migrations/v3.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/frame/elections-phragmen/src/migrations/v3.rs b/frame/elections-phragmen/src/migrations/v3.rs
index 815bdf71591ea..34b8486183ff0 100644
--- a/frame/elections-phragmen/src/migrations/v3.rs
+++ b/frame/elections-phragmen/src/migrations/v3.rs
@@ -68,7 +68,8 @@ type RunnersUp<V, T> = Value<
 #[frame_support::storage_alias]
 type Voting<V, T> = Map<
 	Pallet<T: Config>,
-	(Twox64Concat, T::AccountId),
+	Twox64Concat,
+	<V as V2ToV3>::AccountId,
 	Voter<<V as V2ToV3>::AccountId, <V as V2ToV3>::Balance>,
 >;
 
@@ -85,7 +86,7 @@ pub fn apply<V: V2ToV3, T: Config>(
 	old_voter_bond: V::Balance,
 	old_candidacy_bond: V::Balance,
 ) -> Weight {
-	let storage_version = StorageVersion::get::<T::Pallet>();
+	let storage_version = StorageVersion::get::<Pallet<T>>();
 	log::info!(
 		target: "runtime::elections-phragmen",
 		"Running migration for elections-phragmen with storage version {:?}",

From 676595c012943ec6248a2dd00e876c675193c277 Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@parity.io>
Date: Wed, 11 May 2022 12:16:57 +0100
Subject: [PATCH 19/43] Migrations

---
 Cargo.lock                               |   6 +-
 frame/society/Cargo.toml                 |   1 -
 frame/society/src/lib.rs                 |  86 ++------
 frame/society/src/migrations.rs          | 253 +++++++++++++++++++++++
 frame/support/src/storage/bounded_vec.rs |   6 +
 5 files changed, 280 insertions(+), 72 deletions(-)
 create mode 100644 frame/society/src/migrations.rs

diff --git a/Cargo.lock b/Cargo.lock
index ca7132e7212c8..78cf095cd0942 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3410,9 +3410,9 @@ checksum = "efaa7b300f3b5fe8eb6bf21ce3895e1751d9665086af2d64b42f19701015ff4f"
 
 [[package]]
 name = "libgit2-sys"
-version = "0.13.3+1.4.2"
+version = "0.13.2+1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c24d36c3ac9b9996a2418d6bf428cc0bc5d1a814a84303fc60986088c5ed60de"
+checksum = "3a42de9a51a5c12e00fc0e4ca6bc2ea43582fc6418488e8f615e905d886f258b"
 dependencies = [
  "cc",
  "libc",
@@ -11098,7 +11098,7 @@ dependencies = [
  "chrono",
  "lazy_static",
  "matchers",
- "parking_lot 0.9.0",
+ "parking_lot 0.11.2",
  "regex",
  "serde",
  "serde_json",
diff --git a/frame/society/Cargo.toml b/frame/society/Cargo.toml
index d6979ecde128e..f02188f46ed76 100644
--- a/frame/society/Cargo.toml
+++ b/frame/society/Cargo.toml
@@ -21,7 +21,6 @@ sp-std = { version = "4.0.0", default-features = false, path = "../../primitives
 sp-arithmetic = { version = "5.0.0", default-features = false, path = "../../primitives/arithmetic" }
 frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
 frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
-rand_chacha = { version = "0.2", default-features = false }
 hex-literal = "0.3.4"
 
 [dev-dependencies]
diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index 74cea2f3e6e84..d20dc81d15def 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -469,8 +469,6 @@ pub enum OldVote {
 
 #[frame_support::pallet]
 pub mod pallet {
-	use frame_support::dispatch::PaysFee;
-
 	use super::*;
 
 	#[pallet::pallet]
@@ -594,7 +592,7 @@ pub mod pallet {
 		/// The skeptic has already been punished for this offence.
 		AlreadyPunished,
 		/// Funds are insufficient to pay off society debts.
-		insufficientFunds,
+		InsufficientFunds,
 	}
 
 	#[pallet::event]
@@ -739,54 +737,6 @@ pub mod pallet {
 	pub(super) type DefenderVotes<T: Config<I>, I: 'static = ()> =
 		StorageMap<_, Twox64Concat, T::AccountId, Vote>;
 
-	mod old {
-		use super::{
-			pallet, StorageMap, StorageValue, StorageDoubleMap, Config, BalanceOf, Twox64Concat,
-			ValueQuery, BidKind, VouchingStatus, StrikeCount, Bid,
-		};
-
-		#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
-		pub enum Vote {
-			Skeptic,
-			Reject,
-			Approve,
-		}
-
-		#[pallet::storage]
-		pub type Bids<T: Config<I>, I: 'static = ()> =
-			StorageValue<_, Vec<Bid<T::AccountId, BalanceOf<T, I>>>, ValueQuery>;
-		#[pallet::storage]
-		pub type Candidates<T: Config<I>, I: 'static = ()> =
-			StorageValue<_, Vec<Bid<T::AccountId, BalanceOf<T, I>>>, ValueQuery>;
-		#[pallet::storage]
-		pub type Votes<T: Config<I>, I: 'static = ()> =
-			StorageDoubleMap<_, Twox64Concat, T::AccountId, Twox64Concat, T::AccountId, Vote>;
-		#[pallet::storage]
-		pub type SuspendedCandidates<T: Config<I>, I: 'static = ()> =
-			StorageMap<_, Twox64Concat, T::AccountId, (BalanceOf<T, I>, BidKind<T::AccountId, BalanceOf<T, I>>)>;
-		#[pallet::storage]
-		pub type Members<T: Config<I>, I: 'static = ()> =
-			StorageValue<_, Vec<T::AccountId>, ValueQuery>;
-		#[pallet::storage]
-		pub type Vouching<T: Config<I>, I: 'static = ()> =
-			StorageMap<_, Twox64Concat, T::AccountId, VouchingStatus>;
-		#[pallet::storage]
-		pub type Strikes<T: Config<I>, I: 'static = ()> =
-			StorageMap<_, Twox64Concat, T::AccountId, StrikeCount, ValueQuery>;
-		#[pallet::storage]
-		pub type Payouts<T: Config<I>, I: 'static = ()> =
-			StorageMap<_, Twox64Concat, T::AccountId, Vec<(T::BlockNumber, BalanceOf<T, I>)>, ValueQuery>;
-		#[pallet::storage]
-		pub type SuspendedMembers<T: Config<I>, I: 'static = ()> =
-			StorageMap<_, Twox64Concat, T::AccountId, bool, ValueQuery>;
-		#[pallet::storage]
-		pub type Defender<T: Config<I>, I: 'static = ()> =
-			StorageValue<_, T::AccountId>;
-		#[pallet::storage]
-		pub type DefenderVotes<T: Config<I>, I: 'static = ()> =
-			StorageMap<_, Twox64Concat, T::AccountId, Vote>;
-	}
-
 	#[pallet::hooks]
 	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {
 		fn on_initialize(n: T::BlockNumber) -> Weight {
@@ -999,7 +949,7 @@ pub mod pallet {
 			origin: OriginFor<T>,
 			candidate: <T::Lookup as StaticLookup>::Source,
 			approve: bool,
-		) -> DispatchResult {
+		) -> DispatchResultWithPostInfo {
 			let voter = ensure_signed(origin)?;
 			let candidate = T::Lookup::lookup(candidate)?;
 
@@ -1029,7 +979,7 @@ pub mod pallet {
 		/// Total Complexity: O(M + logM)
 		/// # </weight>
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
-		pub fn defender_vote(origin: OriginFor<T>, approve: bool) -> DispatchResult {
+		pub fn defender_vote(origin: OriginFor<T>, approve: bool) -> DispatchResultWithPostInfo {
 			let voter = ensure_signed(origin)?;
 
 			let mut defending = Defending::<T, I>::get().ok_or(Error::<T, I>::NoDefender)?;
@@ -1085,10 +1035,10 @@ pub mod pallet {
 			let mut record = Members::<T, I>::get(&who).ok_or(Error::<T, I>::NotMember)?;
 			let mut payout_record = Payouts::<T, I>::get(&who);
 			ensure!(record.rank == 0, Error::<T, I>::AlreadyElevated);
-			ensure!(amount >= payout_record.paid, Error::<T, I>::insufficientFunds);
+			ensure!(amount >= payout_record.paid, Error::<T, I>::InsufficientFunds);
 
 			T::Currency::transfer(&who, &Self::account_id(), payout_record.paid, AllowDeath)?;
-			payout_record.paid = 0;
+			payout_record.paid = Zero::zero();
 			payout_record.payouts.clear();
 			record.rank = 1;
 			Members::<T, I>::insert(&who, record);
@@ -1187,7 +1137,7 @@ pub mod pallet {
 			origin: OriginFor<T>,
 			who: T::AccountId,
 			forgive: bool,
-		) -> DispatchResult {
+		) -> DispatchResultWithPostInfo {
 			let founder = ensure_signed(origin)?;
 			ensure!(Founder::<T, I>::get() == Some(founder.clone()), Error::<T, I>::NotFounder);
 
@@ -1205,7 +1155,7 @@ pub mod pallet {
 
 			SuspendedMembers::<T, I>::remove(&who);
 			Self::deposit_event(Event::<T, I>::SuspendedMemberJudgement { who, judged: forgive });
-			Ok(Pays::No)
+			Ok(Pays::No.into())
 		}
 
 		/// Change the maximum number of members in society and the maximum number of new candidates
@@ -1241,7 +1191,7 @@ pub mod pallet {
 		/// Punish the skeptic with a strike if they did not vote on a candidate. Callable by the
 		/// candidate.
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
-		pub fn punish_skeptic(origin: OriginFor<T>) -> DispatchResult {
+		pub fn punish_skeptic(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
 			let candidate = ensure_signed(origin)?;
 			let mut candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
 			ensure!(!candidacy.skeptic_struck, Error::<T, I>::AlreadyPunished);
@@ -1254,7 +1204,7 @@ pub mod pallet {
 		/// Transform an approved candidate into a member. Callable only by the
 		/// the candidate, and only after the period for voting has ended.
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
-		pub fn claim_membership(origin: OriginFor<T>) -> DispatchResult {
+		pub fn claim_membership(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
 			let candidate = ensure_signed(origin)?;
 			let candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
 			ensure!(candidacy.tally.clear_approval(), Error::<T, I>::NotApproved);
@@ -1267,7 +1217,7 @@ pub mod pallet {
 		/// Founder, only after the period for voting has ended and only when the candidate is not
 		/// clearly rejected.
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
-		pub fn bestow_membership(origin: OriginFor<T>, candidate: T::AccountId) -> DispatchResult {
+		pub fn bestow_membership(origin: OriginFor<T>, candidate: T::AccountId) -> DispatchResultWithPostInfo {
 			let founder = ensure_signed(origin)?;
 			ensure!(Founder::<T, I>::get() == Some(founder.clone()), Error::<T, I>::NotFounder);
 			let candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
@@ -1283,7 +1233,7 @@ pub mod pallet {
 		///
 		/// Any bid deposit is lost and voucher is banned.
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
-		pub fn kick_candidate(origin: OriginFor<T>, candidate: T::AccountId) -> DispatchResult {
+		pub fn kick_candidate(origin: OriginFor<T>, candidate: T::AccountId) -> DispatchResultWithPostInfo {
 			let founder = ensure_signed(origin)?;
 			ensure!(Founder::<T, I>::get() == Some(founder.clone()), Error::<T, I>::NotFounder);
 			let mut candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
@@ -1293,14 +1243,14 @@ pub mod pallet {
 			Self::reject_candidate(&candidate, &candidacy.kind);
 			Votes::<T, I>::remove_prefix(&candidate, None);
 			Candidates::<T, I>::remove(&candidate);
-			Ok(Pays::No)
+			Ok(Pays::No.into())
 		}
 
 		/// Remove the candidate's application from the society. Callable only by the candidate.
 		///
 		/// Any bid deposit is lost and voucher is banned.
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
-		pub fn resign_candidacy(origin: OriginFor<T>) -> DispatchResult {
+		pub fn resign_candidacy(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
 			let candidate = ensure_signed(origin)?;
 			let mut candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
 			if !Self::in_progress(candidacy.round) {
@@ -1309,7 +1259,7 @@ pub mod pallet {
 			Self::reject_candidate(&candidate, &candidacy.kind);
 			Votes::<T, I>::remove_prefix(&candidate, None);
 			Candidates::<T, I>::remove(&candidate);
-			Ok(Pays::No)
+			Ok(Pays::No.into())
 		}
 
 		/// Remove a `candidate`'s failed application from the society. Callable by any
@@ -1318,7 +1268,7 @@ pub mod pallet {
 		///
 		/// The bid deposit is lost and the voucher is banned.
 		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
-		pub fn drop_candidate(origin: OriginFor<T>, candidate: T::AccountId) -> DispatchResult {
+		pub fn drop_candidate(origin: OriginFor<T>, candidate: T::AccountId) -> DispatchResultWithPostInfo {
 			ensure_signed(origin)?;
 			let candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
 			ensure!(candidacy.tally.clear_rejection(), Error::<T, I>::NotRejected);
@@ -1326,7 +1276,7 @@ pub mod pallet {
 			Self::reject_candidate(&candidate, &candidacy.kind);
 			Votes::<T, I>::remove_prefix(&candidate, None);
 			Candidates::<T, I>::remove(&candidate);
-			Ok(Pays::No)
+			Ok(Pays::No.into())
 		}
 	}
 }
@@ -1405,9 +1355,9 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 
 	/// Returns `true` if a punishment was given.
 	fn check_skeptic(candidate: &T::AccountId, candidacy: &mut Candidacy<T::AccountId, BalanceOf<T, I>>) -> bool {
-		if RoundCount::<T, I>::get() != candidacy.round || candidacy.skeptic_struck { return }
+		if RoundCount::<T, I>::get() != candidacy.round || candidacy.skeptic_struck { return false }
 		// We expect the skeptic to have voted.
-		let skeptic = match Skeptic::<T, I>::get() { Some(s) => s, None => return };
+		let skeptic = match Skeptic::<T, I>::get() { Some(s) => s, None => return false };
 		let maybe_vote = Votes::<T, I>::get(&candidate, &skeptic);
 		let approved = candidacy.tally.clear_approval();
 		let rejected = candidacy.tally.clear_rejection();
diff --git a/frame/society/src/migrations.rs b/frame/society/src/migrations.rs
new file mode 100644
index 0000000000000..c41cbb24122fe
--- /dev/null
+++ b/frame/society/src/migrations.rs
@@ -0,0 +1,253 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2020-2022 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! # Migrations for Society Pallet
+
+use super::*;
+use frame_support::traits::Instance;
+
+mod old {
+	use super::*;
+	use frame_support::storage_alias;
+
+	/// A vote by a member on a candidate application.
+	#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+	pub enum Vote {
+		/// The member has been chosen to be skeptic and has not yet taken any action.
+		Skeptic,
+		/// The member has rejected the candidate's application.
+		Reject,
+		/// The member approves of the candidate's application.
+		Approve,
+	}
+
+	#[storage_alias] pub type Bids<T, I> = Value<
+		pallet::Pallet<T: Config<I>, I: Instance + 'static>,
+		Vec<Bid<<T as frame_system::Config>::AccountId, BalanceOf<T, I>>>,
+		ValueQuery,
+	>;
+	#[storage_alias] pub type Candidates<T, I> = Value<
+		Pallet<T: Config<I>, I: Instance + 'static>,
+		Vec<Bid<<T as frame_system::Config>::AccountId, BalanceOf<T, I>>>,
+		ValueQuery,
+	>;
+	#[storage_alias] pub type Votes<T, I> = DoubleMap<
+		Pallet<T: Config<I>, I: Instance + 'static>,
+		Twox64Concat, <T as frame_system::Config>::AccountId,
+		Twox64Concat, <T as frame_system::Config>::AccountId,
+		Vote,
+	>;
+	#[storage_alias] pub type SuspendedCandidates<T, I> = Map<
+		Pallet<T: Config<I>, I: Instance + 'static>,
+		Twox64Concat, <T as frame_system::Config>::AccountId,
+		(BalanceOf<T, I>, BidKind<<T as frame_system::Config>::AccountId, BalanceOf<T, I>>),
+	>;
+	#[storage_alias] pub type Members<T, I> = Value<
+		Pallet<T: Config<I>, I: Instance + 'static>,
+		Vec<<T as frame_system::Config>::AccountId>,
+		ValueQuery,
+	>;
+	#[storage_alias] pub type Vouching<T, I> = Map<
+		Pallet<T: Config<I>, I: Instance + 'static>,
+		Twox64Concat, <T as frame_system::Config>::AccountId,
+		VouchingStatus,
+	>;
+	#[storage_alias] pub type Strikes<T, I> = Map<
+		Pallet<T: Config<I>, I: Instance + 'static>,
+		Twox64Concat, <T as frame_system::Config>::AccountId,
+		StrikeCount,
+		ValueQuery,
+	>;
+	#[storage_alias] pub type Payouts<T, I> = Map<
+		Pallet<T: Config<I>, I: Instance + 'static>,
+		Twox64Concat, <T as frame_system::Config>::AccountId,
+		Vec<(<T as frame_system::Config>::BlockNumber, BalanceOf<T, I>)>,
+		ValueQuery,
+	>;
+	#[storage_alias] pub type SuspendedMembers<T, I> = Map<
+		Pallet<T: Config<I>, I: Instance + 'static>,
+		Twox64Concat, <T as frame_system::Config>::AccountId,
+		bool,
+		ValueQuery,
+	>;
+	#[storage_alias] pub type Defender<T, I> = Value<
+		Pallet<T: Config<I>, I: Instance + 'static>,
+		<T as frame_system::Config>::AccountId,
+	>;
+	#[storage_alias] pub type DefenderVotes<T, I> = Map<
+		Pallet<T: Config<I>, I: Instance + 'static>,
+		Twox64Concat, <T as frame_system::Config>::AccountId,
+		Vote,
+	>;
+}
+
+pub fn can_migrate<T: Config<I>, I: Instance + 'static>() -> bool {
+	old::Members::<T, I>::exists()
+}
+
+/// Will panic if there are any inconsistencies in the pallet's state or old keys remaining.
+pub fn assert_internal_consistency<T: Config<I>, I: Instance + 'static>() {
+	// Check all members are valid data.
+	let mut members = vec![];
+	for m in Members::<T, I>::iter_keys() {
+		let r = Members::<T, I>::get(&m).expect("Member data must be valid");
+		members.push((m, r));
+	}
+	assert_eq!(MemberCount::<T, I>::get(), members.len() as u32);
+	for (who, record) in members.iter() {
+		assert_eq!(MemberByIndex::<T, I>::get(record.index).as_ref(), Some(who));
+	}
+	assert_eq!(Founder::<T, I>::get().as_ref(), members.first().map(|m| &m.0));
+	if let Some(head) = Head::<T, I>::get() {
+		assert!(Members::<T, I>::contains_key(head));
+	}
+	// Check all votes are valid data.
+	for (k1, k2) in Votes::<T, I>::iter_keys() {
+		assert!(Votes::<T, I>::get(k1, k2).is_some());
+	}
+	// Check all defender votes are valid data.
+	for k in DefenderVotes::<T, I>::iter_keys() {
+		assert!(DefenderVotes::<T, I>::get(k).is_some());
+	}
+	// Check all candidates are valid data.
+	for k in Candidates::<T, I>::iter_keys() {
+		assert!(Candidates::<T, I>::get(k).is_some());
+	}
+	// Check all suspended members are valid data.
+	for m in SuspendedMembers::<T, I>::iter_keys() {
+		assert!(SuspendedMembers::<T, I>::get(m).is_some());
+	}
+	// Check all payouts are valid data.
+	for p in Payouts::<T, I>::iter_keys() {
+		let have_value = Payouts::<T, I>::contains_key(&p);
+		let is_non_default_value = Payouts::<T, I>::get(&p) != Default::default();
+		// If we have a value it should not be the default value.
+		assert!(have_value == is_non_default_value);
+	}
+
+	// We don't use these - make sure they don't exist.
+	assert_eq!(old::SuspendedCandidates::<T, I>::iter().count(), 0);
+	assert_eq!(old::Strikes::<T, I>::iter().count(), 0);
+	assert_eq!(old::Vouching::<T, I>::iter().count(), 0);
+	assert!(!old::Defender::<T, I>::exists());
+	assert!(!old::Members::<T, I>::exists());
+}
+
+pub fn from_original<
+	T: Config<I>,
+	I: Instance + 'static,
+>(
+	past_payouts: &mut [(<T as frame_system::Config>::AccountId, BalanceOf<T, I>)]
+) {
+	// First check that this is the original state layout. This is easy since the original layout
+	// contained the Members value, and this value no longer exists in the new layout.
+	if !old::Members::<T, I>::exists() {
+		// Already migrated or no data to migrate: Bail.
+		return
+	}
+
+	// Migrate Bids from old::Bids (just a trunctation).
+	Bids::<T, I>::put(BoundedVec::<_, T::MaxBids>::truncate_from(old::Bids::<T, I>::take()));
+
+	// Initialise round counter.
+	RoundCount::<T, I>::put(0);
+
+	// Migrate Candidates from old::Candidates
+	for Bid { who: candidate, kind, value } in old::Candidates::<T, I>::take().into_iter() {
+		let mut tally = Tally::default();
+		// Migrate Votes from old::Votes
+		// No need to drain, since we're overwriting values.
+		for (voter, vote) in old::Votes::<T, I>::iter_prefix(&candidate) {
+			Votes::<T, I>::insert(&candidate, &voter, Vote {
+				approve: vote == old::Vote::Approve,
+				weight: 1,
+			});
+			match vote {
+				old::Vote::Approve => tally.approvals.saturating_inc(),
+				old::Vote::Reject => tally.rejections.saturating_inc(),
+				old::Vote::Skeptic => Skeptic::<T, I>::put(&voter),
+			}
+		}
+		Candidates::<T, I>::insert(&candidate, Candidacy {
+			round: 0,
+			kind,
+			tally,
+			skeptic_struck: false,
+			bid: value,
+		});
+	}
+
+	// Migrate Members from old::Members old::Strikes old::Vouching
+	let mut member_count = 0;
+	for member in old::Members::<T, I>::take() {
+		let strikes = old::Strikes::<T, I>::get(&member);
+		let vouching = old::Vouching::<T, I>::get(&member);
+		Members::<T, I>::insert(&member, MemberRecord {
+			index: member_count,
+			rank: 0,
+			strikes,
+			vouching,
+		});
+		MemberByIndex::<T, I>::insert(member_count, &member);
+		member_count.saturating_inc();
+	}
+
+	// Migrate Payouts from: old::Payouts and raw info (needed since we can't query old chain state).
+	past_payouts.sort();
+	for (who, mut payouts) in old::Payouts::<T, I>::iter() {
+		payouts.truncate(T::MaxPayouts::get() as usize);
+		// ^^ Safe since we already truncated.
+		let paid = past_payouts
+			.binary_search_by_key(&&who, |x| &x.0)
+			.ok()
+			.map(|p| past_payouts[p].1)
+			.unwrap_or(Zero::zero());
+		match BoundedVec::try_from(payouts) {
+			Ok(payouts) => Payouts::<T, I>::insert(who, PayoutRecord { paid, payouts }),
+			Err(_) => debug_assert!(false, "Truncation of Payouts ineffective??"),
+		}
+	}
+
+	// Any suspended candidates remaining are rejected.
+	old::SuspendedCandidates::<T, I>::remove_all(None);
+
+	// Any suspended members remaining are given the benefit of the doubt.
+	old::SuspendedMembers::<T, I>::remove_all(None);
+
+	// We give the current defender the benefit of the doubt.
+	old::Defender::<T, I>::kill();
+	old::DefenderVotes::<T, I>::remove_all(None);
+}
+
+pub fn from_raw_past_payouts<
+	T: Config<I>,
+	I: Instance + 'static,
+>(
+	past_payouts_raw: &[(&[u8], u128)]
+) -> Vec<(<T as frame_system::Config>::AccountId, BalanceOf<T, I>)> {
+	past_payouts_raw.iter()
+		.filter_map(|(x, y)| Some((
+			Decode::decode(&mut x.as_ref()).ok()?,
+			(*y).try_into().ok()?,
+		)))
+		.collect()
+}
+
+//	use hex_literal::hex;
+//	let mut past_payouts_raw = vec![
+//		(hex!["1234567890123456789012345678901234567890123456789012345678901234"], 0u128),
+//	];
diff --git a/frame/support/src/storage/bounded_vec.rs b/frame/support/src/storage/bounded_vec.rs
index 120dd354f78e2..9f87e0918a710 100644
--- a/frame/support/src/storage/bounded_vec.rs
+++ b/frame/support/src/storage/bounded_vec.rs
@@ -233,6 +233,12 @@ impl<T, S: Get<u32>> BoundedVec<T, S> {
 		Self::with_bounded_capacity(Self::bound())
 	}
 
+	/// Consume and truncate the vector `v` in order to create a new instance of `Self` from it.
+	pub fn truncate_from(mut v: Vec<T>) -> Self {
+		v.truncate(Self::bound());
+		Self::unchecked_from(v)
+	}
+
 	/// Get the bound of the type in `usize`.
 	pub fn bound() -> usize {
 		S::get() as usize

From 0fe52d88713d28c6e0ca7bb0d264288f3ebe0a68 Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@parity.io>
Date: Wed, 11 May 2022 13:51:37 +0100
Subject: [PATCH 20/43] Fix tests and add migration testing

---
 frame/society/src/migrations.rs     |  37 +++---
 frame/society/src/mock.rs           |  12 +-
 frame/society/src/tests.rs          | 168 ++++++++++++++++++++++------
 frame/support/src/traits/storage.rs |   6 +
 4 files changed, 169 insertions(+), 54 deletions(-)

diff --git a/frame/society/src/migrations.rs b/frame/society/src/migrations.rs
index c41cbb24122fe..b34410f056d2c 100644
--- a/frame/society/src/migrations.rs
+++ b/frame/society/src/migrations.rs
@@ -20,7 +20,7 @@
 use super::*;
 use frame_support::traits::Instance;
 
-mod old {
+pub(crate) mod old {
 	use super::*;
 	use frame_support::storage_alias;
 
@@ -111,7 +111,9 @@ pub fn assert_internal_consistency<T: Config<I>, I: Instance + 'static>() {
 	for (who, record) in members.iter() {
 		assert_eq!(MemberByIndex::<T, I>::get(record.index).as_ref(), Some(who));
 	}
-	assert_eq!(Founder::<T, I>::get().as_ref(), members.first().map(|m| &m.0));
+	if let Some(founder) = Founder::<T, I>::get() {
+		assert_eq!(Members::<T, I>::get(founder).expect("founder is member").index, 0);
+	}
 	if let Some(head) = Head::<T, I>::get() {
 		assert!(Members::<T, I>::contains_key(head));
 	}
@@ -133,10 +135,9 @@ pub fn assert_internal_consistency<T: Config<I>, I: Instance + 'static>() {
 	}
 	// Check all payouts are valid data.
 	for p in Payouts::<T, I>::iter_keys() {
-		let have_value = Payouts::<T, I>::contains_key(&p);
-		let is_non_default_value = Payouts::<T, I>::get(&p) != Default::default();
-		// If we have a value it should not be the default value.
-		assert!(have_value == is_non_default_value);
+		let k = Payouts::<T, I>::hashed_key_for(&p);
+		let v = frame_support::storage::unhashed::get_raw(&k[..]).expect("value is in map");
+		assert!(PayoutRecordFor::<T, I>::decode(&mut &v[..]).is_ok());
 	}
 
 	// We don't use these - make sure they don't exist.
@@ -194,17 +195,14 @@ pub fn from_original<
 	// Migrate Members from old::Members old::Strikes old::Vouching
 	let mut member_count = 0;
 	for member in old::Members::<T, I>::take() {
-		let strikes = old::Strikes::<T, I>::get(&member);
-		let vouching = old::Vouching::<T, I>::get(&member);
-		Members::<T, I>::insert(&member, MemberRecord {
-			index: member_count,
-			rank: 0,
-			strikes,
-			vouching,
-		});
+		let strikes = old::Strikes::<T, I>::take(&member);
+		let vouching = old::Vouching::<T, I>::take(&member);
+		let record = MemberRecord { index: member_count, rank: 0, strikes, vouching };
+		Members::<T, I>::insert(&member, record);
 		MemberByIndex::<T, I>::insert(member_count, &member);
 		member_count.saturating_inc();
 	}
+	MemberCount::<T, I>::put(member_count);
 
 	// Migrate Payouts from: old::Payouts and raw info (needed since we can't query old chain state).
 	past_payouts.sort();
@@ -222,12 +220,17 @@ pub fn from_original<
 		}
 	}
 
+	// Migrate SuspendedMembers from old::SuspendedMembers old::Strikes old::Vouching.
+	for who in old::SuspendedMembers::<T, I>::iter_keys() {
+		let strikes = old::Strikes::<T, I>::take(&who);
+		let vouching = old::Vouching::<T, I>::take(&who);
+		let record = MemberRecord { index: 0, rank: 0, strikes, vouching };
+		SuspendedMembers::<T, I>::insert(&who, record);
+	}
+
 	// Any suspended candidates remaining are rejected.
 	old::SuspendedCandidates::<T, I>::remove_all(None);
 
-	// Any suspended members remaining are given the benefit of the doubt.
-	old::SuspendedMembers::<T, I>::remove_all(None);
-
 	// We give the current defender the benefit of the doubt.
 	old::Defender::<T, I>::kill();
 	old::DefenderVotes::<T, I>::remove_all(None);
diff --git a/frame/society/src/mock.rs b/frame/society/src/mock.rs
index b2c5f698be1f2..10404cbae1e0f 100644
--- a/frame/society/src/mock.rs
+++ b/frame/society/src/mock.rs
@@ -149,8 +149,8 @@ impl EnvBuilder {
 		pallet_society::GenesisConfig::<Test> {
 			pot: self.pot,
 		}
-		.assimilate_storage(&mut t)
-		.unwrap();
+			.assimilate_storage(&mut t)
+			.unwrap();
 		let mut ext: sp_io::TestExternalities = t.into();
 		ext.execute_with(|| {
 			if self.founded {
@@ -158,7 +158,7 @@ impl EnvBuilder {
 				assert!(Society::found_society(Origin::signed(1), 10, 10, 8, 2, 25, r).is_ok());
 			}
 			let r = f();
-			migrations::assert_internal_consistency();
+			migrations::assert_internal_consistency::<Test, ()>();
 			r
 		})
 	}
@@ -270,6 +270,12 @@ pub fn members() -> Vec<u128> {
 	r
 }
 
+pub fn membership() -> Vec<(u128, MemberRecord)> {
+	let mut r = Members::<Test>::iter().collect::<Vec<_>>();
+	r.sort_by_key(|x| x.0);
+	r
+}
+
 pub fn candidacies() -> Vec<(u128, Candidacy<u128, u64>)> {
 	let mut r = Candidates::<Test>::iter().collect::<Vec<_>>();
 	r.sort_by_key(|x| x.0);
diff --git a/frame/society/src/tests.rs b/frame/society/src/tests.rs
index 5519d5d14284d..4c095b75ffaaf 100644
--- a/frame/society/src/tests.rs
+++ b/frame/society/src/tests.rs
@@ -19,10 +19,110 @@
 
 use super::*;
 use mock::*;
+use migrations::old;
 
 use frame_support::{assert_noop, assert_ok};
 use sp_core::blake2_256;
 use sp_runtime::traits::BadOrigin;
+use VouchingStatus::*;
+use BidKind::*;
+
+#[test]
+fn migration_works() {
+	EnvBuilder::new().founded(false).execute(|| {
+		use old::Vote::*;
+
+		// Initialise the old storage items.
+		Founder::<Test>::put(10);
+		Head::<Test>::put(30);
+		old::Members::<Test, ()>::put(vec![10, 20, 30]);
+		old::Vouching::<Test, ()>::insert(30, Vouching);
+		old::Vouching::<Test, ()>::insert(40, Banned);
+		old::Strikes::<Test, ()>::insert(20, 1);
+		old::Strikes::<Test, ()>::insert(30, 2);
+		old::Strikes::<Test, ()>::insert(40, 5);
+		old::Payouts::<Test, ()>::insert(20, vec![(1, 1)]);
+		old::Payouts::<Test, ()>::insert(30, (0..=<Test as Config>::MaxPayouts::get()).map(|i| (i as u64, i as u64)).collect::<Vec<_>>());
+		old::SuspendedMembers::<Test, ()>::insert(40, true);
+
+		old::Defender::<Test, ()>::put(20);
+		old::DefenderVotes::<Test, ()>::insert(10, Approve);
+		old::DefenderVotes::<Test, ()>::insert(20, Approve);
+		old::DefenderVotes::<Test, ()>::insert(30, Reject);
+
+		old::SuspendedCandidates::<Test, ()>::insert(50, (10, Deposit(100)));
+
+		old::Candidates::<Test, ()>::put(vec![
+			Bid { who: 60, kind: Deposit(100), value: 200 },
+			Bid { who: 70, kind: Vouch(30, 30), value: 100 },
+		]);
+		old::Votes::<Test, ()>::insert(60, 10, Approve);
+		old::Votes::<Test, ()>::insert(70, 10, Reject);
+		old::Votes::<Test, ()>::insert(70, 20, Approve);
+		old::Votes::<Test, ()>::insert(70, 30, Approve);
+
+		let bids = (0..=<Test as Config>::MaxBids::get())
+			.map(|i| Bid {
+				who: 100u128 + i as u128,
+				kind: Deposit(20u64 + i as u64),
+				value: 10u64 + i as u64,
+			})
+			.collect::<Vec<_>>();
+		old::Bids::<Test, ()>::put(bids);
+
+		migrations::from_original::<Test, ()>(&mut[][..]);
+		migrations::assert_internal_consistency::<Test, ()>();
+
+		assert_eq!(membership(), vec![
+			(10, MemberRecord { rank: 0, strikes: 0, vouching: None, index: 0 }),
+			(20, MemberRecord { rank: 0, strikes: 1, vouching: None, index: 1 }),
+			(30, MemberRecord { rank: 0, strikes: 2, vouching: Some(Vouching), index: 2 }),
+		]);
+		assert_eq!(Payouts::<Test>::get(10), PayoutRecord::default());
+		let payouts = vec![(1, 1)].try_into().unwrap();
+		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts });
+		let payouts = (0..<Test as Config>::MaxPayouts::get())
+			.map(|i| (i as u64, i as u64))
+			.collect::<Vec<_>>()
+			.try_into()
+			.unwrap();
+		assert_eq!(Payouts::<Test>::get(30), PayoutRecord { paid: 0, payouts });
+		assert_eq!(SuspendedMembers::<Test>::iter().collect::<Vec<_>>(), vec![
+			(40, MemberRecord { rank: 0, strikes: 5, vouching: Some(Banned), index: 0 }),
+		]);
+		let bids: BoundedVec<_, <Test as Config>::MaxBids> = (0..<Test as Config>::MaxBids::get())
+			.map(|i| Bid {
+				who: 100u128 + i as u128,
+				kind: Deposit(20u64 + i as u64),
+				value: 10u64 + i as u64,
+			})
+			.collect::<Vec<_>>()
+			.try_into()
+			.unwrap();
+		assert_eq!(Bids::<Test>::get(), bids);
+		assert_eq!(RoundCount::<Test, ()>::get(), 0);
+		assert_eq!(candidacies(), vec![
+			(60, Candidacy {
+				round: 0,
+				kind: Deposit(100),
+				bid: 200,
+				tally: Tally { approvals: 1, rejections: 0 },
+				skeptic_struck: false,
+			}),
+			(70, Candidacy {
+				round: 0,
+				kind: Vouch(30, 30),
+				bid: 100,
+				tally: Tally { approvals: 2, rejections: 1 },
+				skeptic_struck: false,
+			}),
+		]);
+		assert_eq!(Votes::<Test>::get(60, 10), Some(Vote { approve: true, weight: 1}));
+		assert_eq!(Votes::<Test>::get(70, 10), Some(Vote { approve: false, weight: 1}));
+		assert_eq!(Votes::<Test>::get(70, 20), Some(Vote { approve: true, weight: 1}));
+		assert_eq!(Votes::<Test>::get(70, 30), Some(Vote { approve: true, weight: 1}));
+	});
+}
 
 #[test]
 fn founding_works() {
@@ -91,7 +191,7 @@ fn basic_new_member_works() {
 		// Rotate period every 4 blocks
 		next_intake();
 		// 20 is now a candidate
-		assert_eq!(candidacies(), vec![(20, candidacy(1, 0, BidKind::Deposit(25), 0, 0))]);
+		assert_eq!(candidacies(), vec![(20, candidacy(1, 0, Deposit(25), 0, 0))]);
 		// 10 (a member) can vote for the candidate
 		assert_ok!(Society::vote(Origin::signed(10), 20, true));
 		conclude_intake(true, None);
@@ -122,8 +222,8 @@ fn bidding_works() {
 		assert_eq!(
 			candidacies(),
 			vec![
-				(30, candidacy(1, 300, BidKind::Deposit(25), 0, 0)),
-				(40, candidacy(1, 400, BidKind::Deposit(25), 0, 0)),
+				(30, candidacy(1, 300, Deposit(25), 0, 0)),
+				(40, candidacy(1, 400, Deposit(25), 0, 0)),
 			]
 		);
 		// A member votes for these candidates to join the society
@@ -137,7 +237,7 @@ fn bidding_works() {
 		assert_eq!(Balances::free_balance(Society::account_id()), 9_300);
 		assert_eq!(Pot::<Test>::get(), 1_300);
 		// Left over from the original bids is 50 who satisfies the condition of bid less than pot.
-		assert_eq!(candidacies(), vec![(50, candidacy(2, 500, BidKind::Deposit(25), 0, 0))]);
+		assert_eq!(candidacies(), vec![(50, candidacy(2, 500, Deposit(25), 0, 0))]);
 		// 40, now a member, can vote for 50
 		assert_ok!(Society::vote(Origin::signed(40), 50, true));
 		conclude_intake(true, None);
@@ -159,7 +259,7 @@ fn bidding_works() {
 		// No payouts
 		assert_eq!(Balances::free_balance(Society::account_id()), 8_800);
 		// Candidate 60 now qualifies based on the increased pot size.
-		assert_eq!(candidacies(), vec![(60, candidacy(4, 1900, BidKind::Deposit(25), 0, 0))]);
+		assert_eq!(candidacies(), vec![(60, candidacy(4, 1900, Deposit(25), 0, 0))]);
 		// Candidate 60 is voted in.
 		assert_ok!(Society::vote(Origin::signed(50), 60, true));
 		conclude_intake(true, None);
@@ -189,7 +289,7 @@ fn unbidding_works() {
 		assert_eq!(Balances::reserved_balance(30), 0);
 		// 20 wins candidacy
 		next_intake();
-		assert_eq!(candidacies(), vec![(20, candidacy(1, 1000, BidKind::Deposit(25), 0, 0))]);
+		assert_eq!(candidacies(), vec![(20, candidacy(1, 1000, Deposit(25), 0, 0))]);
 	});
 }
 
@@ -217,7 +317,7 @@ fn non_voting_skeptic_is_punished() {
 		assert_eq!(Members::<Test>::get(10).unwrap().strikes, 0);
 		assert_ok!(Society::bid(Origin::signed(20), 0));
 		next_intake();
-		assert_eq!(candidacies(), vec![(20, candidacy(1, 0, BidKind::Deposit(25), 0, 0))]);
+		assert_eq!(candidacies(), vec![(20, candidacy(1, 0, Deposit(25), 0, 0))]);
 		conclude_intake(true, None);
 		next_intake();
 		assert_eq!(members(), vec![10]);
@@ -254,7 +354,7 @@ fn basic_new_member_reject_works() {
 		assert_eq!(Balances::reserved_balance(20), 25);
 		// Rotation Period
 		next_intake();
-		assert_eq!(candidacies(), vec![(20, candidacy(1, 0, BidKind::Deposit(25), 0, 0))]);
+		assert_eq!(candidacies(), vec![(20, candidacy(1, 0, Deposit(25), 0, 0))]);
 		// We say no
 		assert_ok!(Society::vote(Origin::signed(10), 20, false));
 		conclude_intake(true, None);
@@ -369,10 +469,10 @@ fn suspended_candidate_rejected_works() {
 		// Rotation Period
 		next_intake();
 		assert_eq!(candidacies(), vec![
-			(40, candidacy(1, 10, BidKind::Deposit(25), 0, 0)),
-			(50, candidacy(1, 10, BidKind::Deposit(25), 0, 0)),
-			(60, candidacy(1, 10, BidKind::Deposit(25), 0, 0)),
-			(70, candidacy(1, 10, BidKind::Deposit(25), 0, 0)),
+			(40, candidacy(1, 10, Deposit(25), 0, 0)),
+			(50, candidacy(1, 10, Deposit(25), 0, 0)),
+			(60, candidacy(1, 10, Deposit(25), 0, 0)),
+			(70, candidacy(1, 10, Deposit(25), 0, 0)),
 		]);
 
 		// Split vote over all.
@@ -447,10 +547,10 @@ fn unpaid_vouch_works() {
 			Error::<Test>::AlreadyVouching
 		);
 		// Vouching creates the right kind of bid
-		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(20, BidKind::Vouch(10, 100), 1000)]);
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(20, Vouch(10, 100), 1000)]);
 		// Vouched user can become candidate
 		next_intake();
-		assert_eq!(candidacies(), vec![(20, candidacy(1, 1000, BidKind::Vouch(10, 100), 0, 0))]);
+		assert_eq!(candidacies(), vec![(20, candidacy(1, 1000, Vouch(10, 100), 0, 0))]);
 		// Vote yes
 		assert_ok!(Society::vote(Origin::signed(10), 20, true));
 		// Vouched user can win
@@ -471,10 +571,10 @@ fn paid_vouch_works() {
 
 		assert_ok!(Society::vouch(Origin::signed(20), 30, 1000, 100));
 		assert_eq!(Members::<Test>::get(20).unwrap().vouching, Some(VouchingStatus::Vouching));
-		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(30, BidKind::Vouch(20, 100), 1000)]);
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(30, Vouch(20, 100), 1000)]);
 
 		next_intake();
-		assert_eq!(candidacies(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20, 100), 0, 0))]);
+		assert_eq!(candidacies(), vec![(30, candidacy(1, 1000, Vouch(20, 100), 0, 0))]);
 		assert_ok!(Society::vote(Origin::signed(20), 30, true));
 		conclude_intake(true, None);
 
@@ -495,10 +595,10 @@ fn voucher_cannot_win_more_than_bid() {
 		// 20 vouches, but asks for more than the bid
 		assert_ok!(Society::vouch(Origin::signed(20), 30, 100, 1000));
 		// Vouching creates the right kind of bid
-		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(30, BidKind::Vouch(20, 1000), 100)]);
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(30, Vouch(20, 1000), 100)]);
 		// Vouched user can become candidate
 		next_intake();
-		assert_eq!(candidacies(), vec![(30, candidacy(1, 100, BidKind::Vouch(20, 1000), 0, 0))]);
+		assert_eq!(candidacies(), vec![(30, candidacy(1, 100, Vouch(20, 1000), 0, 0))]);
 		// Vote yes
 		assert_ok!(Society::vote(Origin::signed(20), 30, true));
 		// Vouched user can win
@@ -519,7 +619,7 @@ fn unvouch_works() {
 		// 10 vouches for 20
 		assert_ok!(Society::vouch(Origin::signed(10), 20, 100, 0));
 		// 20 has a bid
-		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(20, BidKind::Vouch(10, 0), 100)]);
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(20, Vouch(10, 0), 100)]);
 		// 10 is vouched
 		assert_eq!(Members::<Test>::get(10).unwrap().vouching, Some(VouchingStatus::Vouching));
 		// 10 can unvouch
@@ -532,7 +632,7 @@ fn unvouch_works() {
 		// Cannot unvouch after they become candidate
 		assert_ok!(Society::vouch(Origin::signed(10), 20, 100, 0));
 		next_intake();
-		assert_eq!(candidacies(), vec![(20, candidacy(1, 100, BidKind::Vouch(10, 0), 0, 0))]);
+		assert_eq!(candidacies(), vec![(20, candidacy(1, 100, Vouch(10, 0), 0, 0))]);
 		assert_noop!(Society::unvouch(Origin::signed(10)), Error::<Test>::NotVouchingOnBidder);
 
 		// 10 is still vouching until candidate is approved or rejected
@@ -542,7 +642,7 @@ fn unvouch_works() {
 		// But their pick doesn't resign (yet).
 		conclude_intake(false, None);
 		// Voting still happening and voucher cannot unvouch.
-		assert_eq!(candidacies(), vec![(20, candidacy(1, 100, BidKind::Vouch(10, 0), 0, 1))]);
+		assert_eq!(candidacies(), vec![(20, candidacy(1, 100, Vouch(10, 0), 0, 1))]);
 		assert_eq!(Members::<Test>::get(10).unwrap().vouching, Some(VouchingStatus::Vouching));
 
 		// Candidate gives in and resigns.
@@ -569,7 +669,7 @@ fn unbid_vouch_works() {
 		// 10 vouches for 20
 		assert_ok!(Society::vouch(Origin::signed(10), 20, 100, 0));
 		// 20 has a bid
-		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(20, BidKind::Vouch(10, 0), 100)]);
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(20, Vouch(10, 0), 100)]);
 		// 10 is vouched
 		assert_eq!(Members::<Test>::get(10).unwrap().vouching, Some(VouchingStatus::Vouching));
 		// 20 doesn't want to be a member and can unbid themselves.
@@ -791,7 +891,7 @@ fn vouching_handles_removed_member_with_bid() {
 		// Have that member vouch for a user
 		assert_ok!(Society::vouch(Origin::signed(20), 30, 1000, 100));
 		// That user is now a bid and the member is vouching
-		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(30, BidKind::Vouch(20, 100), 1000)]);
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(30, Vouch(20, 100), 1000)]);
 		assert_eq!(Members::<Test>::get(20).unwrap().vouching, Some(VouchingStatus::Vouching));
 		// Suspend that member
 		assert_ok!(Society::suspend_member(&20));
@@ -811,18 +911,18 @@ fn vouching_handles_removed_member_with_candidate() {
 		// Have that member vouch for a user
 		assert_ok!(Society::vouch(Origin::signed(20), 30, 1000, 100));
 		// That user is now a bid and the member is vouching
-		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(30, BidKind::Vouch(20, 100), 1000)]);
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(30, Vouch(20, 100), 1000)]);
 		assert_eq!(Members::<Test>::get(20).unwrap().vouching, Some(VouchingStatus::Vouching));
 
 		// Make that bid a candidate
 		next_intake();
-		assert_eq!(candidacies(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20, 100), 0, 0))]);
+		assert_eq!(candidacies(), vec![(30, candidacy(1, 1000, Vouch(20, 100), 0, 0))]);
 		// Suspend that member
 		assert_ok!(Society::suspend_member(&20));
 		assert_eq!(SuspendedMembers::<Test>::contains_key(20), true);
 
 		// Nothing changes yet in the candidacy, though the member now forgets.
-		assert_eq!(candidacies(), vec![(30, candidacy(1, 1000, BidKind::Vouch(20, 100), 0, 0))]);
+		assert_eq!(candidacies(), vec![(30, candidacy(1, 1000, Vouch(20, 100), 0, 0))]);
 
 		// Candidate wins
 		assert_ok!(Society::vote(Origin::signed(10), 30, true));
@@ -879,9 +979,9 @@ fn max_bids_work() {
 		// Length is 1000
 		assert_eq!(bids.len(), 10);
 		// First bid is smallest number (100)
-		assert_eq!(bids[0], bid(100, BidKind::Deposit(25), 0));
+		assert_eq!(bids[0], bid(100, Deposit(25), 0));
 		// Last bid is smallest number + 99 (1099)
-		assert_eq!(bids[9], bid(109, BidKind::Deposit(25), 9));
+		assert_eq!(bids[9], bid(109, Deposit(25), 9));
 	});
 }
 
@@ -970,16 +1070,16 @@ fn zero_bid_works() {
 		assert_eq!(
 			candidacies(),
 			vec![
-				(30, candidacy(1, 0, BidKind::Deposit(25), 0, 0)),
-				(50, candidacy(1, 300, BidKind::Deposit(25), 0, 0)),
-				(60, candidacy(1, 400, BidKind::Deposit(25), 0, 0)),
+				(30, candidacy(1, 0, Deposit(25), 0, 0)),
+				(50, candidacy(1, 300, Deposit(25), 0, 0)),
+				(60, candidacy(1, 400, Deposit(25), 0, 0)),
 			]
 		);
 		assert_eq!(
 			Bids::<Test>::get(),
 			vec![
-				bid(20, BidKind::Deposit(25), 0),
-				bid(40, BidKind::Deposit(25), 0),
+				bid(20, Deposit(25), 0),
+				bid(40, Deposit(25), 0),
 			],
 		);
 		// A member votes for these candidates to join the society
@@ -1013,7 +1113,7 @@ fn bids_ordered_correctly() {
 
 		for j in 0..5 {
 			for i in 0..5 {
-				final_list.push(bid(100 + (i * 5 + j) as u128, BidKind::Deposit(25), j));
+				final_list.push(bid(100 + (i * 5 + j) as u128, Deposit(25), j));
 			}
 		}
 		let max_bids: u32 = <Test as Config>::MaxBids::get();
diff --git a/frame/support/src/traits/storage.rs b/frame/support/src/traits/storage.rs
index e484140cc2fd9..5bc0b470480e2 100644
--- a/frame/support/src/traits/storage.rs
+++ b/frame/support/src/traits/storage.rs
@@ -33,6 +33,12 @@ pub trait Instance: 'static {
 	const INDEX: u8;
 }
 
+// Dummy implementation for `()`.
+impl Instance for () {
+	const PREFIX: &'static str = "";
+	const INDEX: u8 = 0;
+}
+
 /// An instance of a storage in a pallet.
 ///
 /// Define an instance for an individual storage inside a pallet.

From 27abee7e109398ac784519d7b36bea8bbb122f82 Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@parity.io>
Date: Wed, 11 May 2022 14:40:11 +0100
Subject: [PATCH 21/43] Introduce lazy-cleanup and avoid unbounded prefix
 removal

---
 frame/society/src/lib.rs                      | 64 +++++++++++++++----
 frame/society/src/migrations.rs               |  4 +-
 frame/society/src/tests.rs                    | 50 +++++++++------
 primitives/state-machine/src/ext.rs           |  5 +-
 .../src/overlayed_changes/changeset.rs        |  5 +-
 .../src/overlayed_changes/mod.rs              |  4 +-
 6 files changed, 90 insertions(+), 42 deletions(-)

diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index d20dc81d15def..d806ee6b73308 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -469,7 +469,9 @@ pub enum OldVote {
 
 #[frame_support::pallet]
 pub mod pallet {
-	use super::*;
+	use sp_io::KillStorageResult;
+
+use super::*;
 
 	#[pallet::pallet]
 	#[pallet::generate_store(pub(super) trait Store)]
@@ -593,6 +595,8 @@ pub mod pallet {
 		AlreadyPunished,
 		/// Funds are insufficient to pay off society debts.
 		InsufficientFunds,
+		/// The candidate/defender has no stale votes to remove.
+		NoVotes,
 	}
 
 	#[pallet::event]
@@ -728,14 +732,18 @@ pub mod pallet {
 		OptionQuery,
 	>;
 
+	/// The number of challenge rounds there have been. Used to identify stale DefenderVotes.
+	#[pallet::storage]
+	pub(super) type ChallengeRoundCount<T: Config<I>, I: 'static = ()> = StorageValue<_, RoundIndex, ValueQuery>;
+
 	/// The defending member currently being challenged, along with a running tally of votes.
 	#[pallet::storage]
 	pub(super) type Defending<T: Config<I>, I: 'static = ()> = StorageValue<_, (T::AccountId, T::AccountId, Tally)>;
 
-	/// Votes for the defender.
+	/// Votes for the defender, keyed by challenge round.
 	#[pallet::storage]
 	pub(super) type DefenderVotes<T: Config<I>, I: 'static = ()> =
-		StorageMap<_, Twox64Concat, T::AccountId, Vote>;
+		StorageDoubleMap<_, Twox64Concat, RoundIndex, Twox64Concat, T::AccountId, Vote>;
 
 	#[pallet::hooks]
 	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {
@@ -985,7 +993,8 @@ pub mod pallet {
 			let mut defending = Defending::<T, I>::get().ok_or(Error::<T, I>::NoDefender)?;
 			let record = Members::<T, I>::get(&voter).ok_or(Error::<T, I>::NotMember)?;
 
-			let first_time = DefenderVotes::<T, I>::mutate(&voter, |v| {
+			let round = ChallengeRoundCount::<T, I>::get();
+			let first_time = DefenderVotes::<T, I>::mutate(round, &voter, |v| {
 				let first_time = v.is_none();
 				*v = Some(Self::do_vote(*v, approve, record.rank, &mut defending.2));
 				first_time
@@ -1241,7 +1250,6 @@ pub mod pallet {
 			ensure!(!candidacy.tally.clear_approval(), Error::<T, I>::Approved);
 			Self::check_skeptic(&candidate, &mut candidacy);
 			Self::reject_candidate(&candidate, &candidacy.kind);
-			Votes::<T, I>::remove_prefix(&candidate, None);
 			Candidates::<T, I>::remove(&candidate);
 			Ok(Pays::No.into())
 		}
@@ -1257,7 +1265,6 @@ pub mod pallet {
 				Self::check_skeptic(&candidate, &mut candidacy);
 			}
 			Self::reject_candidate(&candidate, &candidacy.kind);
-			Votes::<T, I>::remove_prefix(&candidate, None);
 			Candidates::<T, I>::remove(&candidate);
 			Ok(Pays::No.into())
 		}
@@ -1274,10 +1281,42 @@ pub mod pallet {
 			ensure!(candidacy.tally.clear_rejection(), Error::<T, I>::NotRejected);
 			ensure!(RoundCount::<T, I>::get() > candidacy.round + 1, Error::<T, I>::TooEarly);
 			Self::reject_candidate(&candidate, &candidacy.kind);
-			Votes::<T, I>::remove_prefix(&candidate, None);
 			Candidates::<T, I>::remove(&candidate);
 			Ok(Pays::No.into())
 		}
+
+		/// Remove up to `max` stale votes for the given `candidate`.
+		///
+		/// May be called by any Signed origin, but only after the candidate's candidacy is ended.
+		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		pub fn cleanup_candidacy(origin: OriginFor<T>, candidate: T::AccountId, max: u32) -> DispatchResultWithPostInfo {
+			ensure_signed(origin)?;
+			ensure!(!Candidates::<T, I>::contains_key(&candidate), Error::<T, I>::InProgress);
+			match Votes::<T, I>::remove_prefix(&candidate, Some(max)) {
+				KillStorageResult::AllRemoved(0) => {
+					dbg!(Votes::<T, I>::iter_prefix(&candidate).collect::<Vec<_>>());
+					Err(Error::<T, I>::NoVotes.into())
+				},
+				_ => Ok(Pays::No.into()),
+			}
+		}
+
+		/// Remove up to `max` stale votes for the defender in the given `challenge_round`.
+		///
+		/// May be called by any Signed origin, but only after the challenge round is ended.
+		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		pub fn cleanup_challenge(
+			origin: OriginFor<T>,
+			challenge_round: RoundIndex,
+			max: u32,
+		) -> DispatchResultWithPostInfo {
+			ensure_signed(origin)?;
+			ensure!(challenge_round < ChallengeRoundCount::<T, I>::get(), Error::<T, I>::InProgress);
+			match DefenderVotes::<T, I>::remove_prefix(challenge_round, Some(max)) {
+				KillStorageResult::AllRemoved(0) => Err(Error::<T, I>::NoVotes.into()),
+				_ => Ok(Pays::No.into()),
+			}
+		}
 	}
 }
 
@@ -1381,6 +1420,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	/// End the current challenge period and start a new one.
 	fn rotate_challenge(rng: &mut impl RngCore) {
 		let mut next_defender = None;
+		let mut round = ChallengeRoundCount::<T, I>::get();
 
 		// End current defender rotation
 		if let Some((defender, skeptic, tally)) = Defending::<T, I>::get() {
@@ -1392,7 +1432,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 			}
 
 			// Check defender skeptic voted and that their vote was with the majority.
-			let skeptic_vote = DefenderVotes::<T, I>::get(&skeptic);
+			let skeptic_vote = DefenderVotes::<T, I>::get(round, &skeptic);
 			match (skeptic_vote, tally.more_approvals(), tally.more_rejections()) {
 				(None, _, _)
 				| (Some(Vote { approve: true, .. }), false, true)
@@ -1408,11 +1448,8 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 				}
 				_ => {}
 			}
-
-			// Clean up all votes.
-			// NOTE: To do lazy removal of this we'll need to store the challenge round so that
-			// voting when there's a stale vote does not lead to incorrect arithmetic.
-			DefenderVotes::<T, I>::remove_all(None);
+			round.saturating_inc();
+			ChallengeRoundCount::<T, I>::put(round);
 		}
 
 		// Avoid challenging if there's only two members since we never challenge the Head or
@@ -1633,7 +1670,6 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		let maturity = now + Self::lock_duration(MemberCount::<T, I>::get());
 		Self::reward_bidder(&candidate, candidacy.bid, candidacy.kind, maturity);
 
-		Votes::<T, I>::remove_prefix(&candidate, None);
 		Candidates::<T, I>::remove(&candidate);
 		Ok(())
 	}
diff --git a/frame/society/src/migrations.rs b/frame/society/src/migrations.rs
index b34410f056d2c..b616de0077b1e 100644
--- a/frame/society/src/migrations.rs
+++ b/frame/society/src/migrations.rs
@@ -122,8 +122,8 @@ pub fn assert_internal_consistency<T: Config<I>, I: Instance + 'static>() {
 		assert!(Votes::<T, I>::get(k1, k2).is_some());
 	}
 	// Check all defender votes are valid data.
-	for k in DefenderVotes::<T, I>::iter_keys() {
-		assert!(DefenderVotes::<T, I>::get(k).is_some());
+	for (k1, k2) in DefenderVotes::<T, I>::iter_keys() {
+		assert!(DefenderVotes::<T, I>::get(k1, k2).is_some());
 	}
 	// Check all candidates are valid data.
 	for k in Candidates::<T, I>::iter_keys() {
diff --git a/frame/society/src/tests.rs b/frame/society/src/tests.rs
index 4c095b75ffaaf..49ddf4bc264f8 100644
--- a/frame/society/src/tests.rs
+++ b/frame/society/src/tests.rs
@@ -762,10 +762,10 @@ fn challenges_work() {
 		// Add some members
 		place_members([20, 30, 40]);
 		// Votes are empty
-		assert_eq!(DefenderVotes::<Test>::get(10), None);
-		assert_eq!(DefenderVotes::<Test>::get(20), None);
-		assert_eq!(DefenderVotes::<Test>::get(30), None);
-		assert_eq!(DefenderVotes::<Test>::get(40), None);
+		assert_eq!(DefenderVotes::<Test>::get(0, 10), None);
+		assert_eq!(DefenderVotes::<Test>::get(0, 20), None);
+		assert_eq!(DefenderVotes::<Test>::get(0, 30), None);
+		assert_eq!(DefenderVotes::<Test>::get(0, 40), None);
 		// Check starting point
 		assert_eq!(members(), vec![10, 20, 30, 40]);
 		assert_eq!(Defending::<Test>::get(), None);
@@ -779,6 +779,8 @@ fn challenges_work() {
 		// If no one else votes, nothing happens
 		next_challenge();
 		assert_eq!(members(), vec![10, 20, 30, 40]);
+		// Reset votes for last challenge
+		assert_ok!(Society::cleanup_challenge(Origin::signed(0), 0, 10));
 		// New challenge period
 		assert_eq!(Defending::<Test>::get().unwrap().0, 30);
 		// Non-member cannot vote
@@ -792,11 +794,13 @@ fn challenges_work() {
 		next_challenge();
 		// 30 survives
 		assert_eq!(members(), vec![10, 20, 30, 40]);
+		// Reset votes for last challenge
+		assert_ok!(Society::cleanup_challenge(Origin::signed(0), 1, 10));
 		// Votes are reset
-		assert_eq!(DefenderVotes::<Test>::get(10), None);
-		assert_eq!(DefenderVotes::<Test>::get(20), None);
-		assert_eq!(DefenderVotes::<Test>::get(30), None);
-		assert_eq!(DefenderVotes::<Test>::get(40), None);
+		assert_eq!(DefenderVotes::<Test>::get(0, 10), None);
+		assert_eq!(DefenderVotes::<Test>::get(0, 20), None);
+		assert_eq!(DefenderVotes::<Test>::get(0, 30), None);
+		assert_eq!(DefenderVotes::<Test>::get(0, 40), None);
 
 		// One more time
 		assert_eq!(Defending::<Test>::get().unwrap().0, 30);
@@ -805,8 +809,8 @@ fn challenges_work() {
 		assert_ok!(Society::defender_vote(Origin::signed(20), true));
 		assert_ok!(Society::defender_vote(Origin::signed(30), false));
 		assert_ok!(Society::defender_vote(Origin::signed(40), false));
-		next_challenge();
 
+		next_challenge();
 		// 30 is suspended
 		assert_eq!(members(), vec![10, 20, 40]);
 		assert_eq!(SuspendedMembers::<Test>::get(30), Some(MemberRecord {
@@ -815,14 +819,15 @@ fn challenges_work() {
 			vouching: None,
 			index: 2,
 		}));
-
+		// Reset votes for last challenge
+		assert_ok!(Society::cleanup_challenge(Origin::signed(0), 2, 10));
 		// New defender is chosen
 		assert_eq!(Defending::<Test>::get().unwrap().0, 20);
 		// Votes are reset
-		assert_eq!(DefenderVotes::<Test>::get(10), None);
-		assert_eq!(DefenderVotes::<Test>::get(20), None);
-		assert_eq!(DefenderVotes::<Test>::get(30), None);
-		assert_eq!(DefenderVotes::<Test>::get(40), None);
+		assert_eq!(DefenderVotes::<Test>::get(0, 10), None);
+		assert_eq!(DefenderVotes::<Test>::get(0, 20), None);
+		assert_eq!(DefenderVotes::<Test>::get(0, 30), None);
+		assert_eq!(DefenderVotes::<Test>::get(0, 40), None);
 	});
 }
 
@@ -951,17 +956,20 @@ fn votes_are_working() {
 		// You cannot vote for a non-candidate
 		assert_noop!(Society::vote(Origin::signed(10), 50, true), Error::<Test>::NotCandidate);
 		// Votes are stored
-		assert_eq!(<Votes<Test>>::get(30, 10), Some(Vote { approve: true, weight: 4 }));
-		assert_eq!(<Votes<Test>>::get(30, 20), Some(Vote { approve: true, weight: 1 }));
-		assert_eq!(<Votes<Test>>::get(40, 10), Some(Vote { approve: true, weight: 4 }));
-		assert_eq!(<Votes<Test>>::get(50, 10), None);
+		assert_eq!(Votes::<Test>::get(30, 10), Some(Vote { approve: true, weight: 4 }));
+		assert_eq!(Votes::<Test>::get(30, 20), Some(Vote { approve: true, weight: 1 }));
+		assert_eq!(Votes::<Test>::get(40, 10), Some(Vote { approve: true, weight: 4 }));
+		assert_eq!(Votes::<Test>::get(50, 10), None);
 		conclude_intake(false, None);
+		// Cleanup the candidacy
+		assert_ok!(Society::cleanup_candidacy(Origin::signed(0), 30, 10));
+		assert_ok!(Society::cleanup_candidacy(Origin::signed(0), 40, 10));
 		// Candidates become members after a period rotation
 		assert_eq!(members(), vec![10, 20, 30, 40]);
 		// Votes are cleaned up
-		assert_eq!(<Votes<Test>>::get(30, 10), None);
-		assert_eq!(<Votes<Test>>::get(30, 20), None);
-		assert_eq!(<Votes<Test>>::get(40, 10), None);
+		assert_eq!(Votes::<Test>::get(30, 10), None);
+		assert_eq!(Votes::<Test>::get(30, 20), None);
+		assert_eq!(Votes::<Test>::get(40, 10), None);
 	});
 }
 
diff --git a/primitives/state-machine/src/ext.rs b/primitives/state-machine/src/ext.rs
index e33569e2a1f67..2d446b9c3b9a0 100644
--- a/primitives/state-machine/src/ext.rs
+++ b/primitives/state-machine/src/ext.rs
@@ -464,8 +464,9 @@ where
 		}
 
 		self.mark_dirty();
-		self.overlay.clear_prefix(prefix);
-		self.limit_remove_from_backend(None, Some(prefix), limit)
+		let overlay_count = self.overlay.clear_prefix(prefix);
+		let (all, count) = self.limit_remove_from_backend(None, Some(prefix), limit);
+		(all, count + overlay_count)
 	}
 
 	fn clear_child_prefix(
diff --git a/primitives/state-machine/src/overlayed_changes/changeset.rs b/primitives/state-machine/src/overlayed_changes/changeset.rs
index 9e7f6ffeddfd7..c0f9d60f75539 100644
--- a/primitives/state-machine/src/overlayed_changes/changeset.rs
+++ b/primitives/state-machine/src/overlayed_changes/changeset.rs
@@ -410,10 +410,13 @@ impl OverlayedChangeSet {
 		&mut self,
 		predicate: impl Fn(&[u8], &OverlayedValue) -> bool,
 		at_extrinsic: Option<u32>,
-	) {
+	) -> u32 {
+		let mut count = 0;
 		for (key, val) in self.changes.iter_mut().filter(|(k, v)| predicate(k, v)) {
 			val.set(None, insert_dirty(&mut self.dirty_keys, key.clone()), at_extrinsic);
+			count += 1;
 		}
+		count
 	}
 
 	/// Get the iterator over all changes that follow the supplied `key`.
diff --git a/primitives/state-machine/src/overlayed_changes/mod.rs b/primitives/state-machine/src/overlayed_changes/mod.rs
index 2161b343711c9..2bb09e98bff62 100644
--- a/primitives/state-machine/src/overlayed_changes/mod.rs
+++ b/primitives/state-machine/src/overlayed_changes/mod.rs
@@ -315,8 +315,8 @@ impl OverlayedChanges {
 	/// Removes all key-value pairs which keys share the given prefix.
 	///
 	/// Can be rolled back or committed when called inside a transaction.
-	pub(crate) fn clear_prefix(&mut self, prefix: &[u8]) {
-		self.top.clear_where(|key, _| key.starts_with(prefix), self.extrinsic_index());
+	pub(crate) fn clear_prefix(&mut self, prefix: &[u8]) -> u32 {
+		self.top.clear_where(|key, _| key.starts_with(prefix), self.extrinsic_index())
 	}
 
 	/// Removes all key-value pairs which keys share the given prefix.

From adccb6674406d6892aff37455b7c949ab1a15c9c Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@parity.io>
Date: Wed, 18 May 2022 16:16:21 +0200
Subject: [PATCH 22/43] Fixes

---
 frame/support/src/storage/types/map.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/frame/support/src/storage/types/map.rs b/frame/support/src/storage/types/map.rs
index 80250dbc60796..98e34eaf4f3c6 100644
--- a/frame/support/src/storage/types/map.rs
+++ b/frame/support/src/storage/types/map.rs
@@ -351,7 +351,7 @@ where
 	/// order.
 	///
 	/// If you alter the map while doing this, you'll get undefined results.
-	pub fn iter_keys_from_from(starting_key: impl EncodeLike<Key>) -> crate::storage::KeyPrefixIterator<Key> {
+	pub fn iter_keys_from_key(starting_key: impl EncodeLike<Key>) -> crate::storage::KeyPrefixIterator<Key> {
 		Self::iter_keys_from(Self::hashed_key_for(starting_key))
 	}
 

From aefd6db21a52d15aad55ae074ed32466c52af71d Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@parity.io>
Date: Wed, 1 Jun 2022 10:21:50 +0100
Subject: [PATCH 23/43] Fixes

---
 frame/society/src/lib.rs        | 23 ++++++++++-------
 frame/society/src/migrations.rs | 44 +++++++++++++++----------------
 frame/system/src/lib.rs         |  2 +-
 primitives/core/src/crypto.rs   | 46 +++++++++++++++++++++++++++++++++
 primitives/core/src/ecdsa.rs    |  2 +-
 primitives/core/src/ed25519.rs  |  3 ++-
 primitives/core/src/sr25519.rs  |  4 +--
 primitives/core/src/traits.rs   | 46 ---------------------------------
 primitives/runtime/src/lib.rs   |  3 +--
 9 files changed, 88 insertions(+), 85 deletions(-)

diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index ab1223c4b47a6..987a5bcdf8717 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -469,9 +469,7 @@ pub enum OldVote {
 
 #[frame_support::pallet]
 pub mod pallet {
-	use sp_io::KillStorageResult;
-
-use super::*;
+	use super::*;
 
 	#[pallet::pallet]
 	#[pallet::generate_store(pub(super) trait Store)]
@@ -723,6 +721,14 @@ use super::*;
 		OptionQuery,
 	>;
 
+	/// Clear-cursor for Vote, map from Candidate -> (Maybe) Cursor.
+	#[pallet::storage]
+	pub type VoteClearCursor<T: Config<I>, I: 'static = ()> = StorageMap<_,
+		Twox64Concat,
+		T::AccountId,
+		BoundedVec<u8, KeyLenOf::<Votes>>,
+	>;
+
 	/// At the end of the claim period, this contains the most recently approved members (along with
 	/// their bid and round ID) who is from the most recent round with the lowest bid. They will
 	/// become the new `Head`.
@@ -1297,13 +1303,10 @@ use super::*;
 		pub fn cleanup_candidacy(origin: OriginFor<T>, candidate: T::AccountId, max: u32) -> DispatchResultWithPostInfo {
 			ensure_signed(origin)?;
 			ensure!(!Candidates::<T, I>::contains_key(&candidate), Error::<T, I>::InProgress);
-			match Votes::<T, I>::remove_prefix(&candidate, Some(max)) {
-				KillStorageResult::AllRemoved(0) => {
-					dbg!(Votes::<T, I>::iter_prefix(&candidate).collect::<Vec<_>>());
-					Err(Error::<T, I>::NoVotes.into())
-				},
-				_ => Ok(Pays::No.into()),
-			}
+			let maybe_cursor = VoteClearCursor::<T, I>::get(&candidate);
+			let r = Votes::<T, I>::clear_prefix(&candidate, Some(max), maybe_cursor.as_ref().map(|x| &x[..]));
+			VoteClearCursor::<T, I>::set(&candidate, r.maybe_cursor.map(BoundedVec::truncate_from));
+			Ok(if r.loops == 0 { Pays::Yes } else { Pays::No }.into())
 		}
 
 		/// Remove up to `max` stale votes for the defender in the given `challenge_round`.
diff --git a/frame/society/src/migrations.rs b/frame/society/src/migrations.rs
index b616de0077b1e..eb5a8f2019167 100644
--- a/frame/society/src/migrations.rs
+++ b/frame/society/src/migrations.rs
@@ -35,61 +35,61 @@ pub(crate) mod old {
 		Approve,
 	}
 
-	#[storage_alias] pub type Bids<T, I> = Value<
-		pallet::Pallet<T: Config<I>, I: Instance + 'static>,
+	#[storage_alias] pub type Bids<T: Config<I>, I: 'static> = StorageValue<
+		Pallet<T, I>,
 		Vec<Bid<<T as frame_system::Config>::AccountId, BalanceOf<T, I>>>,
 		ValueQuery,
 	>;
-	#[storage_alias] pub type Candidates<T, I> = Value<
-		Pallet<T: Config<I>, I: Instance + 'static>,
+	#[storage_alias] pub type Candidates<T: Config<I>, I: 'static> = StorageValue<
+		Pallet<T, I>,
 		Vec<Bid<<T as frame_system::Config>::AccountId, BalanceOf<T, I>>>,
 		ValueQuery,
 	>;
-	#[storage_alias] pub type Votes<T, I> = DoubleMap<
-		Pallet<T: Config<I>, I: Instance + 'static>,
+	#[storage_alias] pub type Votes<T: Config<I>, I: 'static> = StorageDoubleMap<
+		Pallet<T, I>,
 		Twox64Concat, <T as frame_system::Config>::AccountId,
 		Twox64Concat, <T as frame_system::Config>::AccountId,
 		Vote,
 	>;
-	#[storage_alias] pub type SuspendedCandidates<T, I> = Map<
-		Pallet<T: Config<I>, I: Instance + 'static>,
+	#[storage_alias] pub type SuspendedCandidates<T: Config<I>, I: 'static> = StorageMap<
+		Pallet<T, I>,
 		Twox64Concat, <T as frame_system::Config>::AccountId,
 		(BalanceOf<T, I>, BidKind<<T as frame_system::Config>::AccountId, BalanceOf<T, I>>),
 	>;
-	#[storage_alias] pub type Members<T, I> = Value<
-		Pallet<T: Config<I>, I: Instance + 'static>,
+	#[storage_alias] pub type Members<T: Config<I>, I: 'static> = StorageValue<
+		Pallet<T, I>,
 		Vec<<T as frame_system::Config>::AccountId>,
 		ValueQuery,
 	>;
-	#[storage_alias] pub type Vouching<T, I> = Map<
-		Pallet<T: Config<I>, I: Instance + 'static>,
+	#[storage_alias] pub type Vouching<T: Config<I>, I: 'static> = StorageMap<
+		Pallet<T, I>,
 		Twox64Concat, <T as frame_system::Config>::AccountId,
 		VouchingStatus,
 	>;
-	#[storage_alias] pub type Strikes<T, I> = Map<
-		Pallet<T: Config<I>, I: Instance + 'static>,
+	#[storage_alias] pub type Strikes<T: Config<I>, I: 'static> = StorageMap<
+		Pallet<T, I>,
 		Twox64Concat, <T as frame_system::Config>::AccountId,
 		StrikeCount,
 		ValueQuery,
 	>;
-	#[storage_alias] pub type Payouts<T, I> = Map<
-		Pallet<T: Config<I>, I: Instance + 'static>,
+	#[storage_alias] pub type Payouts<T: Config<I>, I: 'static> = StorageMap<
+		Pallet<T, I>,
 		Twox64Concat, <T as frame_system::Config>::AccountId,
 		Vec<(<T as frame_system::Config>::BlockNumber, BalanceOf<T, I>)>,
 		ValueQuery,
 	>;
-	#[storage_alias] pub type SuspendedMembers<T, I> = Map<
-		Pallet<T: Config<I>, I: Instance + 'static>,
+	#[storage_alias] pub type SuspendedMembers<T: Config<I>, I: 'static> = StorageMap<
+		Pallet<T, I>,
 		Twox64Concat, <T as frame_system::Config>::AccountId,
 		bool,
 		ValueQuery,
 	>;
-	#[storage_alias] pub type Defender<T, I> = Value<
-		Pallet<T: Config<I>, I: Instance + 'static>,
+	#[storage_alias] pub type Defender<T: Config<I>, I: 'static> = StorageValue<
+		Pallet<T, I>,
 		<T as frame_system::Config>::AccountId,
 	>;
-	#[storage_alias] pub type DefenderVotes<T, I> = Map<
-		Pallet<T: Config<I>, I: Instance + 'static>,
+	#[storage_alias] pub type DefenderVotes<T: Config<I>, I: 'static> = StorageMap<
+		Pallet<T, I>,
 		Twox64Concat, <T as frame_system::Config>::AccountId,
 		Vote,
 	>;
diff --git a/frame/system/src/lib.rs b/frame/system/src/lib.rs
index 38109294ec90d..cbbaee75149e9 100644
--- a/frame/system/src/lib.rs
+++ b/frame/system/src/lib.rs
@@ -197,7 +197,7 @@ impl<MaxNormal: Get<u32>, MaxOverflow: Get<u32>> ConsumerLimits for (MaxNormal,
 pub mod pallet {
 	use crate::{self as frame_system, pallet_prelude::*, *};
 	use frame_support::pallet_prelude::*;
-	use sp_core::traits::FromEntropy;
+	use sp_core::crypto::FromEntropy;
 
 	/// System configuration trait. Implemented by runtime.
 	#[pallet::config]
diff --git a/primitives/core/src/crypto.rs b/primitives/core/src/crypto.rs
index 80b44449dbac1..8904d8cc2cc49 100644
--- a/primitives/core/src/crypto.rs
+++ b/primitives/core/src/crypto.rs
@@ -1123,6 +1123,52 @@ pub mod key_types {
 	pub const DUMMY: KeyTypeId = KeyTypeId(*b"dumy");
 }
 
+/// Create random values of `Self` given a stream of entropy.
+pub trait FromEntropy: Sized {
+	/// Create a random value of `Self` given a stream of random bytes on `input`. May only fail if
+	/// `input` has an error.
+	fn from_entropy(input: &mut impl codec::Input) -> Result<Self, codec::Error>;
+}
+
+impl FromEntropy for bool {
+	fn from_entropy(input: &mut impl codec::Input) -> Result<Self, codec::Error> {
+		Ok(input.read_byte()? % 2 == 1)
+	}
+}
+
+macro_rules! impl_from_entropy {
+	($type:ty , $( $others:tt )*) => {
+		impl_from_entropy!($type);
+		impl_from_entropy!($( $others )*);
+	};
+	($type:ty) => {
+		impl FromEntropy for $type {
+			fn from_entropy(input: &mut impl codec::Input) -> Result<Self, codec::Error> {
+				<Self as codec::Decode>::decode(input)
+			}
+		}
+	}
+}
+
+macro_rules! impl_from_entropy_base {
+	($type:ty , $( $others:tt )*) => {
+		impl_from_entropy_base!($type);
+		impl_from_entropy_base!($( $others )*);
+	};
+	($type:ty) => {
+		impl_from_entropy!($type,
+			[$type; 1], [$type; 2], [$type; 3], [$type; 4], [$type; 5], [$type; 6], [$type; 7], [$type; 8],
+			[$type; 9], [$type; 10], [$type; 11], [$type; 12], [$type; 13], [$type; 14], [$type; 15], [$type; 16],
+			[$type; 17], [$type; 18], [$type; 19], [$type; 20], [$type; 21], [$type; 22], [$type; 23], [$type; 24],
+			[$type; 25], [$type; 26], [$type; 27], [$type; 28], [$type; 29], [$type; 30], [$type; 31], [$type; 32],
+			[$type; 36], [$type; 40], [$type; 44], [$type; 48], [$type; 56], [$type; 64], [$type; 72], [$type; 80],
+			[$type; 96], [$type; 112], [$type; 128], [$type; 160], [$type; 192], [$type; 224], [$type; 256]
+		);
+	}
+}
+
+impl_from_entropy_base!(u8, u16, u32, u64, u128, i8, i16, i32, i64, i128);
+
 #[cfg(test)]
 mod tests {
 	use super::*;
diff --git a/primitives/core/src/ecdsa.rs b/primitives/core/src/ecdsa.rs
index e37b024bf4cce..b07df85607bc5 100644
--- a/primitives/core/src/ecdsa.rs
+++ b/primitives/core/src/ecdsa.rs
@@ -74,7 +74,7 @@ type Seed = [u8; 32];
 )]
 pub struct Public(pub [u8; 33]);
 
-impl crate::traits::FromEntropy for Public {
+impl crate::crypto::FromEntropy for Public {
 	fn from_entropy(input: &mut impl codec::Input) -> Result<Self, codec::Error> {
 		let mut result = Self([0u8; 33]);
 		input.read(&mut result.0[..])?;
diff --git a/primitives/core/src/ed25519.rs b/primitives/core/src/ed25519.rs
index 9a34fdea73ebe..5dfb94e1cc876 100644
--- a/primitives/core/src/ed25519.rs
+++ b/primitives/core/src/ed25519.rs
@@ -33,6 +33,7 @@ use scale_info::TypeInfo;
 use crate::crypto::Ss58Codec;
 use crate::crypto::{
 	CryptoType, CryptoTypeId, CryptoTypePublicPair, Derive, Public as TraitPublic, UncheckedFrom,
+	FromEntropy,
 };
 #[cfg(feature = "full_crypto")]
 use crate::crypto::{DeriveJunction, Pair as TraitPair, SecretStringError};
@@ -88,7 +89,7 @@ impl Clone for Pair {
 	}
 }
 
-impl crate::traits::FromEntropy for Public {
+impl FromEntropy for Public {
 	fn from_entropy(input: &mut impl codec::Input) -> Result<Self, codec::Error> {
 		let mut result = Self([0u8; 32]);
 		input.read(&mut result.0[..])?;
diff --git a/primitives/core/src/sr25519.rs b/primitives/core/src/sr25519.rs
index 251776c5e8118..72b1ccc9631a7 100644
--- a/primitives/core/src/sr25519.rs
+++ b/primitives/core/src/sr25519.rs
@@ -40,9 +40,9 @@ use substrate_bip39::mini_secret_from_entropy;
 use crate::{
 	crypto::{
 		ByteArray, CryptoType, CryptoTypeId, CryptoTypePublicPair, Derive, Public as TraitPublic,
-		UncheckedFrom,
+		UncheckedFrom, FromEntropy,
 	},
-	hash::{H256, H512}, traits::FromEntropy,
+	hash::{H256, H512},
 };
 use codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
diff --git a/primitives/core/src/traits.rs b/primitives/core/src/traits.rs
index fc4bd908874d3..80e8963a2909d 100644
--- a/primitives/core/src/traits.rs
+++ b/primitives/core/src/traits.rs
@@ -278,49 +278,3 @@ impl SpawnEssentialNamed for Box<dyn SpawnEssentialNamed> {
 		(**self).spawn_essential(name, group, future)
 	}
 }
-
-/// Create random values of `Self` given a stream of entropy.
-pub trait FromEntropy: Sized {
-	/// Create a random value of `Self` given a stream of random bytes on `input`. May only fail if
-	/// `input` has an error.
-	fn from_entropy(input: &mut impl codec::Input) -> Result<Self, codec::Error>;
-}
-
-impl FromEntropy for bool {
-	fn from_entropy(input: &mut impl codec::Input) -> Result<Self, codec::Error> {
-		Ok(input.read_byte()? % 2 == 1)
-	}
-}
-
-macro_rules! impl_from_entropy {
-	($type:ty , $( $others:tt )*) => {
-		impl_from_entropy!($type);
-		impl_from_entropy!($( $others )*);
-	};
-	($type:ty) => {
-		impl FromEntropy for $type {
-			fn from_entropy(input: &mut impl codec::Input) -> Result<Self, codec::Error> {
-				<Self as codec::Decode>::decode(input)
-			}
-		}
-	}
-}
-
-macro_rules! impl_from_entropy_base {
-	($type:ty , $( $others:tt )*) => {
-		impl_from_entropy_base!($type);
-		impl_from_entropy_base!($( $others )*);
-	};
-	($type:ty) => {
-		impl_from_entropy!($type,
-			[$type; 1], [$type; 2], [$type; 3], [$type; 4], [$type; 5], [$type; 6], [$type; 7], [$type; 8],
-			[$type; 9], [$type; 10], [$type; 11], [$type; 12], [$type; 13], [$type; 14], [$type; 15], [$type; 16],
-			[$type; 17], [$type; 18], [$type; 19], [$type; 20], [$type; 21], [$type; 22], [$type; 23], [$type; 24],
-			[$type; 25], [$type; 26], [$type; 27], [$type; 28], [$type; 29], [$type; 30], [$type; 31], [$type; 32],
-			[$type; 36], [$type; 40], [$type; 44], [$type; 48], [$type; 56], [$type; 64], [$type; 72], [$type; 80],
-			[$type; 96], [$type; 112], [$type; 128], [$type; 160], [$type; 192], [$type; 224], [$type; 256]
-		);
-	}
-}
-
-impl_from_entropy_base!(u8, u16, u32, u64, u128, i8, i16, i32, i64, i128);
diff --git a/primitives/runtime/src/lib.rs b/primitives/runtime/src/lib.rs
index 11af6b37d9a67..22d1dc1e2bbef 100644
--- a/primitives/runtime/src/lib.rs
+++ b/primitives/runtime/src/lib.rs
@@ -45,11 +45,10 @@ pub use sp_core::storage::StateVersion;
 pub use sp_core::storage::{Storage, StorageChild};
 
 use sp_core::{
-	crypto::{self, ByteArray},
+	crypto::{self, ByteArray, FromEntropy},
 	ecdsa, ed25519,
 	hash::{H256, H512},
 	sr25519,
-	traits::FromEntropy,
 };
 use sp_std::prelude::*;
 

From be940c1742174a15efaf5a1ac0f88b690f173ece Mon Sep 17 00:00:00 2001
From: Artur Gontijo <arturgontijo@users.noreply.github.com>
Date: Sat, 3 Dec 2022 13:46:31 -0300
Subject: [PATCH 24/43] [WIP][Society] Adding benchmarking to the v2. (#11776)

* [Society] Adding benchmarking to the v2.

* [Society] Code review.

* [Society] Better code.

* Using clear() + clear_prefix() and adding more tests.

* Benchmarking again...
---
 Cargo.lock                        |   1 +
 bin/node/cli/src/chain_spec.rs    |  10 +-
 bin/node/runtime/src/lib.rs       |  24 +-
 bin/node/testing/src/genesis.rs   |   2 +-
 frame/society/Cargo.toml          |   4 +
 frame/society/src/benchmarking.rs | 339 ++++++++++++++++++++++
 frame/society/src/lib.rs          | 112 ++++----
 frame/society/src/migrations.rs   |   4 +-
 frame/society/src/mock.rs         |  13 +-
 frame/society/src/tests.rs        |  68 +++++
 frame/society/src/weights.rs      | 454 ++++++++++++++++++++++++++++++
 frame/system/src/lib.rs           |   4 +-
 12 files changed, 955 insertions(+), 80 deletions(-)
 create mode 100644 frame/society/src/benchmarking.rs
 create mode 100644 frame/society/src/weights.rs

diff --git a/Cargo.lock b/Cargo.lock
index 26f6d41b46326..00fd0ddddb1ac 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6139,6 +6139,7 @@ dependencies = [
 name = "pallet-society"
 version = "4.0.0-dev"
 dependencies = [
+ "frame-benchmarking",
  "frame-support",
  "frame-support-test",
  "frame-system",
diff --git a/bin/node/cli/src/chain_spec.rs b/bin/node/cli/src/chain_spec.rs
index 221c229876275..7faecb6158f75 100644
--- a/bin/node/cli/src/chain_spec.rs
+++ b/bin/node/cli/src/chain_spec.rs
@@ -349,15 +349,7 @@ pub fn testnet_genesis(
 		grandpa: GrandpaConfig { authorities: vec![] },
 		technical_membership: Default::default(),
 		treasury: Default::default(),
-		society: SocietyConfig {
-			members: endowed_accounts
-				.iter()
-				.take((num_endowed_accounts + 1) / 2)
-				.cloned()
-				.collect(),
-			pot: 0,
-			max_members: 999,
-		},
+		society: SocietyConfig { pot: 0 },
 		vesting: Default::default(),
 		assets: Default::default(),
 		gilt: Default::default(),
diff --git a/bin/node/runtime/src/lib.rs b/bin/node/runtime/src/lib.rs
index 3c0202d683787..2420e8ac9656f 100644
--- a/bin/node/runtime/src/lib.rs
+++ b/bin/node/runtime/src/lib.rs
@@ -1313,14 +1313,14 @@ impl pallet_recovery::Config for Runtime {
 }
 
 parameter_types! {
-	pub const CandidateDeposit: Balance = 10 * DOLLARS;
-	pub const WrongSideDeduction: Balance = 2 * DOLLARS;
-	pub const MaxStrikes: u32 = 10;
-	pub const RotationPeriod: BlockNumber = 80 * HOURS;
+	pub const GraceStrikes: u32 = 10;
+	pub const SocietyVotingPeriod: BlockNumber = 80 * HOURS;
+	pub const ClaimPeriod: BlockNumber = 80 * HOURS;
 	pub const PeriodSpend: Balance = 500 * DOLLARS;
 	pub const MaxLockDuration: BlockNumber = 36 * 30 * DAYS;
 	pub const ChallengePeriod: BlockNumber = 7 * DAYS;
-	pub const MaxCandidateIntake: u32 = 10;
+	pub const MaxPayouts: u32 = 10;
+	pub const MaxBids: u32 = 10;
 	pub const SocietyPalletId: PalletId = PalletId(*b"py/socie");
 }
 
@@ -1329,18 +1329,17 @@ impl pallet_society::Config for Runtime {
 	type PalletId = SocietyPalletId;
 	type Currency = Balances;
 	type Randomness = RandomnessCollectiveFlip;
-	type CandidateDeposit = CandidateDeposit;
-	type WrongSideDeduction = WrongSideDeduction;
-	type MaxStrikes = MaxStrikes;
+	type GraceStrikes = GraceStrikes;
 	type PeriodSpend = PeriodSpend;
-	type MembershipChanged = ();
-	type RotationPeriod = RotationPeriod;
+	type VotingPeriod = SocietyVotingPeriod;
+	type ClaimPeriod = ClaimPeriod;
 	type MaxLockDuration = MaxLockDuration;
 	type FounderSetOrigin =
 		pallet_collective::EnsureProportionMoreThan<AccountId, CouncilCollective, 1, 2>;
-	type JudgementOrigin = pallet_society::EnsureFounder<Runtime>;
-	type MaxCandidateIntake = MaxCandidateIntake;
 	type ChallengePeriod = ChallengePeriod;
+	type MaxPayouts = MaxPayouts;
+	type MaxBids = MaxBids;
+	type WeightInfo = pallet_society::weights::SubstrateWeight<Runtime>;
 }
 
 parameter_types! {
@@ -1658,6 +1657,7 @@ mod benches {
 		[pallet_remark, Remark]
 		[pallet_scheduler, Scheduler]
 		[pallet_session, SessionBench::<Runtime>]
+		[pallet_society, Society]
 		[pallet_staking, Staking]
 		[pallet_state_trie_migration, StateTrieMigration]
 		[frame_system, SystemBench::<Runtime>]
diff --git a/bin/node/testing/src/genesis.rs b/bin/node/testing/src/genesis.rs
index 73e7ea50261d3..8cdf9723afd42 100644
--- a/bin/node/testing/src/genesis.rs
+++ b/bin/node/testing/src/genesis.rs
@@ -86,7 +86,7 @@ pub fn config_endowed(code: Option<&[u8]>, extra_endowed: Vec<AccountId>) -> Gen
 		elections: Default::default(),
 		sudo: Default::default(),
 		treasury: Default::default(),
-		society: SocietyConfig { members: vec![alice(), bob()], pot: 0, max_members: 999 },
+		society: SocietyConfig { pot: 0 },
 		vesting: Default::default(),
 		assets: Default::default(),
 		gilt: Default::default(),
diff --git a/frame/society/Cargo.toml b/frame/society/Cargo.toml
index 2c49b56a0e1cf..0edf3e2bcb51b 100644
--- a/frame/society/Cargo.toml
+++ b/frame/society/Cargo.toml
@@ -18,7 +18,9 @@ rand_chacha = { version = "0.2", default-features = false }
 scale-info = { version = "2.1.1", default-features = false, features = ["derive"] }
 sp-runtime = { version = "6.0.0", default-features = false, path = "../../primitives/runtime" }
 sp-std = { version = "4.0.0", default-features = false, path = "../../primitives/std" }
+sp-io = { version = "6.0.0", default-features = false, path = "../../primitives/io" }
 sp-arithmetic = { version = "5.0.0", default-features = false, path = "../../primitives/arithmetic" }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
 frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
 frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
 hex-literal = "0.3.4"
@@ -39,9 +41,11 @@ std = [
 	"scale-info/std",
 	"sp-runtime/std",
 	"sp-std/std",
+	"sp-io/std",
 ]
 runtime-benchmarks = [
 	"frame-system/runtime-benchmarks",
 	"sp-runtime/runtime-benchmarks",
+	"frame-benchmarking/runtime-benchmarks",
 ]
 try-runtime = ["frame-support/try-runtime"]
diff --git a/frame/society/src/benchmarking.rs b/frame/society/src/benchmarking.rs
new file mode 100644
index 0000000000000..4cd4abe5952dc
--- /dev/null
+++ b/frame/society/src/benchmarking.rs
@@ -0,0 +1,339 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2021-2022 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Society pallet benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+
+use frame_benchmarking::{account, benchmarks_instance_pallet, whitelisted_caller};
+use frame_system::RawOrigin;
+
+use sp_runtime::traits::Bounded;
+
+use crate::Pallet as Society;
+
+fn mock_balance_deposit<T: Config<I>, I: 'static>() -> BalanceOf<T, I> {
+	T::Currency::minimum_balance().saturating_mul(1_000u32.into())
+}
+
+// Set up Society
+fn setup_society<T: Config<I>, I: 'static>() -> Result<T::AccountId, &'static str> {
+	let origin = T::FounderSetOrigin::successful_origin();
+	let founder: T::AccountId = account("founder", 0, 0);
+	let max_members = 5u32;
+	let max_intake = 3u32;
+	let max_strikes = 3u32;
+	Society::<T, I>::found_society(
+		origin,
+		founder.clone(),
+		max_members,
+		max_intake,
+		max_strikes,
+		mock_balance_deposit::<T, I>(),
+		b"benchmarking-society".to_vec(),
+	)?;
+	Ok(founder)
+}
+
+fn add_candidate<T: Config<I>, I: 'static>(
+	name: &'static str,
+	tally: Tally,
+	skeptic_struck: bool,
+) -> T::AccountId {
+	let candidate: T::AccountId = account(name, 0, 0);
+	T::Currency::make_free_balance_be(&candidate, BalanceOf::<T, I>::max_value());
+	let candidacy = Candidacy {
+		round: RoundCount::<T, I>::get(),
+		kind: BidKind::Deposit(mock_balance_deposit::<T, I>()),
+		bid: 0u32.into(),
+		tally,
+		skeptic_struck,
+	};
+	Candidates::<T, I>::insert(&candidate, &candidacy);
+	candidate
+}
+
+fn increment_round<T: Config<I>, I: 'static>() {
+	let mut round_count = RoundCount::<T, I>::get();
+	round_count.saturating_inc();
+	RoundCount::<T, I>::put(round_count);
+}
+
+benchmarks_instance_pallet! {
+	bid {
+		let founder = setup_society::<T, I>()?;
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
+	}: _(RawOrigin::Signed(caller.clone()), 10u32.into())
+	verify {
+		let first_bid: Bid<T::AccountId, BalanceOf<T, I>> = Bid {
+			who: caller.clone(),
+			kind: BidKind::Deposit(mock_balance_deposit::<T, I>()),
+			value: 10u32.into(),
+		};
+		assert_eq!(Bids::<T, I>::get(), vec![first_bid]);
+	}
+
+	unbid {
+		let founder = setup_society::<T, I>()?;
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
+		let mut bids = Bids::<T, I>::get();
+		Society::<T, I>::insert_bid(&mut bids, &caller, 10u32.into(), BidKind::Deposit(mock_balance_deposit::<T, I>()));
+		Bids::<T, I>::put(bids);
+	}: _(RawOrigin::Signed(caller.clone()))
+	verify {
+		assert_eq!(Bids::<T, I>::get(), vec![]);
+	}
+
+	vouch {
+		let founder = setup_society::<T, I>()?;
+		let caller: T::AccountId = whitelisted_caller();
+		let vouched: T::AccountId = account("vouched", 0, 0);
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
+		let _ = Society::<T, I>::insert_member(&caller, 1u32.into());
+	}: _(RawOrigin::Signed(caller.clone()), vouched.clone(), 0u32.into(), 0u32.into())
+	verify {
+		let bids = Bids::<T, I>::get();
+		let vouched_bid: Bid<T::AccountId, BalanceOf<T, I>> = Bid {
+			who: vouched.clone(),
+			kind: BidKind::Vouch(caller.clone(), 0u32.into()),
+			value: 0u32.into(),
+		};
+		assert_eq!(bids, vec![vouched_bid]);
+	}
+
+	unvouch {
+		let founder = setup_society::<T, I>()?;
+		let caller: T::AccountId = whitelisted_caller();
+		let vouched: T::AccountId = account("vouched", 0, 0);
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
+		let mut bids = Bids::<T, I>::get();
+		Society::<T, I>::insert_bid(&mut bids, &caller, 10u32.into(), BidKind::Vouch(caller.clone(), 0u32.into()));
+		Bids::<T, I>::put(bids);
+	}: _(RawOrigin::Signed(caller.clone()))
+	verify {
+		assert_eq!(Bids::<T, I>::get(), vec![]);
+	}
+
+	vote {
+		let founder = setup_society::<T, I>()?;
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
+		let _ = Society::<T, I>::insert_member(&caller, 1u32.into());
+		let candidate = add_candidate::<T, I>("candidate", Default::default(), false);
+		let candidate_lookup: <T::Lookup as StaticLookup>::Source = T::Lookup::unlookup(candidate.clone());
+	}: _(RawOrigin::Signed(caller.clone()), candidate_lookup, true)
+	verify {
+		let maybe_vote: Vote = <Votes<T, I>>::get(candidate.clone(), caller).unwrap();
+		assert_eq!(maybe_vote.approve, true);
+	}
+
+	defender_vote {
+		let founder = setup_society::<T, I>()?;
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
+		let _ = Society::<T, I>::insert_member(&caller, 1u32.into());
+		let defender: T::AccountId = account("defender", 0, 0);
+		Defending::<T, I>::put((defender, caller.clone(), Tally::default()));
+	}: _(RawOrigin::Signed(caller.clone()), false)
+	verify {
+		let round = RoundCount::<T, I>::get();
+		let skeptic_vote: Vote = DefenderVotes::<T, I>::get(round, &caller).unwrap();
+		assert_eq!(skeptic_vote.approve, false);
+	}
+
+	payout {
+		let founder = setup_society::<T, I>()?;
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, mock_balance_deposit::<T, I>());
+		let _ = Society::<T, I>::insert_member(&caller, 0u32.into());
+		T::Currency::make_free_balance_be(&Society::<T, I>::payouts(), BalanceOf::<T, I>::max_value());
+		let mut pot = <Pot<T, I>>::get();
+		pot = pot.saturating_add(BalanceOf::<T, I>::max_value());
+		Pot::<T, I>::put(&pot);
+		Society::<T, I>::bump_payout(&caller, 0u32.into(), 1u32.into());
+	}: _(RawOrigin::Signed(caller.clone()))
+	verify {
+		let record = Payouts::<T, I>::get(caller);
+		assert!(record.payouts.is_empty());
+	}
+
+	waive_repay {
+		let founder = setup_society::<T, I>()?;
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
+		let _ = Society::<T, I>::insert_member(&caller, 0u32.into());
+		T::Currency::make_free_balance_be(&Society::<T, I>::payouts(), BalanceOf::<T, I>::max_value());
+		Society::<T, I>::bump_payout(&caller, 0u32.into(), 1u32.into());
+	}: _(RawOrigin::Signed(caller.clone()), 1u32.into())
+	verify {
+		let record = Payouts::<T, I>::get(caller);
+		assert!(record.payouts.is_empty());
+	}
+
+	found_society {
+		let founder: T::AccountId = whitelisted_caller();
+		let can_found = T::FounderSetOrigin::successful_origin();
+	}: _<T::Origin>(can_found, founder.clone(), 5, 3, 3, mock_balance_deposit::<T, I>(), b"benchmarking-society".to_vec())
+	verify {
+		assert_eq!(Founder::<T, I>::get(), Some(founder.clone()));
+	}
+
+	dissolve {
+		let founder = setup_society::<T, I>()?;
+		let members_and_candidates = vec![("m1", "c1"), ("m2", "c2"), ("m3", "c3"), ("m4", "c4")];
+		let members_count = members_and_candidates.clone().len() as u32;
+		for (m, c) in members_and_candidates {
+			let member: T::AccountId = account(m, 0, 0);
+			let _ = Society::<T, I>::insert_member(&member, 100u32.into());
+			let candidate = add_candidate::<T, I>(c, Tally { approvals: 1u32.into(), rejections: 1u32.into() }, false);
+			let candidate_lookup: <T::Lookup as StaticLookup>::Source = T::Lookup::unlookup(candidate);
+			let _ = Society::<T, I>::vote(RawOrigin::Signed(member).into(), candidate_lookup, true);
+		}
+		// Leaving only Founder member.
+		MemberCount::<T, I>::mutate(|i| { i.saturating_reduce(members_count) });
+	}: _(RawOrigin::Signed(founder))
+	verify {
+		assert_eq!(Founder::<T, I>::get(), None);
+	}
+
+	judge_suspended_member {
+		let founder = setup_society::<T, I>()?;
+		let caller: T::AccountId = whitelisted_caller();
+		let _ = Society::<T, I>::insert_member(&caller, 0u32.into());
+		let _ = Society::<T, I>::suspend_member(&caller);
+	}: _(RawOrigin::Signed(founder), caller.clone(), false)
+	verify {
+		assert_eq!(SuspendedMembers::<T, I>::contains_key(&caller), false);
+	}
+
+	set_parameters {
+		let founder = setup_society::<T, I>()?;
+		let max_members = 10u32;
+		let max_intake = 10u32;
+		let max_strikes = 10u32;
+		let candidate_deposit: BalanceOf<T, I> = 10u32.into();
+		let params = GroupParams { max_members, max_intake, max_strikes, candidate_deposit };
+	}: _(RawOrigin::Signed(founder), max_members, max_intake, max_strikes, candidate_deposit)
+	verify {
+		assert_eq!(Parameters::<T, I>::get(), Some(params));
+	}
+
+	punish_skeptic {
+		let founder = setup_society::<T, I>()?;
+		let candidate = add_candidate::<T, I>("candidate", Default::default(), false);
+		let skeptic: T::AccountId = account("skeptic", 0, 0);
+		let _ = Society::<T, I>::insert_member(&skeptic, 0u32.into());
+		Skeptic::<T, I>::put(&skeptic);
+		frame_system::Pallet::<T>::set_block_number(T::VotingPeriod::get() + 1u32.into());
+	}: _(RawOrigin::Signed(candidate.clone()))
+	verify {
+		let candidacy = Candidates::<T, I>::get(&candidate).unwrap();
+		assert_eq!(candidacy.skeptic_struck, true);
+	}
+
+	claim_membership {
+		let founder = setup_society::<T, I>()?;
+		let candidate = add_candidate::<T, I>("candidate", Tally { approvals: 3u32.into(), rejections: 0u32.into() }, false);
+		increment_round::<T, I>();
+	}: _(RawOrigin::Signed(candidate.clone()))
+	verify {
+		assert!(!Candidates::<T, I>::contains_key(&candidate));
+		assert!(Members::<T, I>::contains_key(&candidate));
+	}
+
+	bestow_membership {
+		let founder = setup_society::<T, I>()?;
+		let candidate = add_candidate::<T, I>("candidate", Tally { approvals: 3u32.into(), rejections: 1u32.into() }, false);
+		increment_round::<T, I>();
+	}: _(RawOrigin::Signed(founder), candidate.clone())
+	verify {
+		assert!(!Candidates::<T, I>::contains_key(&candidate));
+		assert!(Members::<T, I>::contains_key(&candidate));
+	}
+
+	kick_candidate {
+		let founder = setup_society::<T, I>()?;
+		let candidate = add_candidate::<T, I>("candidate", Tally { approvals: 1u32.into(), rejections: 1u32.into() }, false);
+		increment_round::<T, I>();
+	}: _(RawOrigin::Signed(founder), candidate.clone())
+	verify {
+		assert!(!Candidates::<T, I>::contains_key(&candidate));
+	}
+
+	resign_candidacy {
+		let founder = setup_society::<T, I>()?;
+		let candidate = add_candidate::<T, I>("candidate", Tally { approvals: 0u32.into(), rejections: 0u32.into() }, false);
+	}: _(RawOrigin::Signed(candidate.clone()))
+	verify {
+		assert!(!Candidates::<T, I>::contains_key(&candidate));
+	}
+
+	drop_candidate {
+		let founder = setup_society::<T, I>()?;
+		let candidate = add_candidate::<T, I>("candidate", Tally { approvals: 0u32.into(), rejections: 3u32.into() }, false);
+		let caller: T::AccountId = whitelisted_caller();
+		let _ = Society::<T, I>::insert_member(&caller, 0u32.into());
+		let mut round_count = RoundCount::<T, I>::get();
+		round_count = round_count.saturating_add(2u32);
+		RoundCount::<T, I>::put(round_count);
+	}: _(RawOrigin::Signed(caller), candidate.clone())
+	verify {
+		assert!(!Candidates::<T, I>::contains_key(&candidate));
+	}
+
+	cleanup_candidacy {
+		let founder = setup_society::<T, I>()?;
+		let candidate = add_candidate::<T, I>("candidate", Tally { approvals: 0u32.into(), rejections: 0u32.into() }, false);
+		let member_one: T::AccountId = account("one", 0, 0);
+		let member_two: T::AccountId = account("two", 0, 0);
+		let _ = Society::<T, I>::insert_member(&member_one, 0u32.into());
+		let _ = Society::<T, I>::insert_member(&member_two, 0u32.into());
+		let candidate_lookup: <T::Lookup as StaticLookup>::Source = T::Lookup::unlookup(candidate.clone());
+		let _ = Society::<T, I>::vote(RawOrigin::Signed(member_one.clone()).into(), candidate_lookup.clone(), true);
+		let _ = Society::<T, I>::vote(RawOrigin::Signed(member_two.clone()).into(), candidate_lookup, true);
+		Candidates::<T, I>::remove(&candidate);
+	}: _(RawOrigin::Signed(member_one), candidate.clone(), 5)
+	verify {
+		assert_eq!(Votes::<T, I>::get(&candidate, &member_two), None);
+	}
+
+	cleanup_challenge {
+		let founder = setup_society::<T, I>()?;
+		ChallengeRoundCount::<T, I>::put(1u32);
+		let member: T::AccountId = whitelisted_caller();
+		let _ = Society::<T, I>::insert_member(&member, 0u32.into());
+		let defender: T::AccountId = account("defender", 0, 0);
+		Defending::<T, I>::put((defender.clone(), member.clone(), Tally::default()));
+		let _ = Society::<T, I>::defender_vote(RawOrigin::Signed(member.clone()).into(), true);
+		ChallengeRoundCount::<T, I>::put(2u32);
+		let mut challenge_round = ChallengeRoundCount::<T, I>::get();
+		challenge_round = challenge_round.saturating_sub(1u32);
+	}: _(RawOrigin::Signed(member.clone()), challenge_round, 1u32)
+	verify {
+		assert_eq!(DefenderVotes::<T, I>::get(challenge_round, &defender), None);
+	}
+
+	impl_benchmark_test_suite!(
+		Society,
+		crate::tests_composite::ExtBuilder::default().build(),
+		crate::tests_composite::Test,
+	)
+}
diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index 987a5bcdf8717..2f5b56b757747 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -250,10 +250,16 @@ mod mock;
 #[cfg(test)]
 mod tests;
 
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+
+pub mod weights;
+
 pub mod migrations;
 
 use frame_support::{
 	pallet_prelude::*,
+	storage::KeyLenOf,
 	traits::{
 		Currency, EnsureOrigin, ExistenceRequirement::AllowDeath,
 		Imbalance, OnUnbalanced, Randomness, ReservableCurrency, BalanceStatus,
@@ -275,6 +281,8 @@ use sp_runtime::{
 };
 use sp_std::prelude::*;
 
+pub use weights::WeightInfo;
+
 pub use pallet::*;
 
 type BalanceOf<T, I> =
@@ -527,6 +535,9 @@ pub mod pallet {
 		/// The maximum number of bids at once.
 		#[pallet::constant]
 		type MaxBids: Get<u32>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
 	}
 
 	#[pallet::error]
@@ -723,10 +734,10 @@ pub mod pallet {
 
 	/// Clear-cursor for Vote, map from Candidate -> (Maybe) Cursor.
 	#[pallet::storage]
-	pub type VoteClearCursor<T: Config<I>, I: 'static = ()> = StorageMap<_,
+	pub(super) type VoteClearCursor<T: Config<I>, I: 'static = ()> = StorageMap<_,
 		Twox64Concat,
 		T::AccountId,
-		BoundedVec<u8, KeyLenOf::<Votes>>,
+		BoundedVec<u8, KeyLenOf<Votes<T, I>>>
 	>;
 
 	/// At the end of the claim period, this contains the most recently approved members (along with
@@ -821,7 +832,7 @@ pub mod pallet {
 		///
 		/// Key: B (len of bids), C (len of candidates), M (len of members), X (balance reserve)
 		/// Total Complexity: O(M + B + C + logM + logB + X)
-		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		#[pallet::weight(T::WeightInfo::bid())]
 		pub fn bid(origin: OriginFor<T>, value: BalanceOf<T, I>) -> DispatchResult {
 			let who = ensure_signed(origin)?;
 
@@ -852,7 +863,7 @@ pub mod pallet {
 		///
 		/// Key: B (len of bids), X (balance unreserve)
 		/// Total Complexity: O(B + X)
-		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		#[pallet::weight(T::WeightInfo::unbid())]
 		pub fn unbid(origin: OriginFor<T>) -> DispatchResult {
 			let who = ensure_signed(origin)?;
 
@@ -884,7 +895,7 @@ pub mod pallet {
 		///
 		/// Key: B (len of bids), C (len of candidates), M (len of members)
 		/// Total Complexity: O(M + B + C + logM + logB + X)
-		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		#[pallet::weight(T::WeightInfo::vouch())]
 		pub fn vouch(
 			origin: OriginFor<T>,
 			who: T::AccountId,
@@ -932,7 +943,7 @@ pub mod pallet {
 		///
 		/// Key: B (len of bids)
 		/// Total Complexity: O(B)
-		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		#[pallet::weight(T::WeightInfo::unvouch())]
 		pub fn unvouch(origin: OriginFor<T>) -> DispatchResult {
 			let voucher = ensure_signed(origin)?;
 
@@ -958,7 +969,7 @@ pub mod pallet {
 		///
 		/// Key: C (len of candidates), M (len of members)
 		/// Total Complexity: O(M + logM + C)
-		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		#[pallet::weight(T::WeightInfo::vote())]
 		pub fn vote(
 			origin: OriginFor<T>,
 			candidate: <T::Lookup as StaticLookup>::Source,
@@ -992,7 +1003,7 @@ pub mod pallet {
 		/// Key: M (len of members)
 		/// Total Complexity: O(M + logM)
 		/// # </weight>
-		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		#[pallet::weight(T::WeightInfo::defender_vote())]
 		pub fn defender_vote(origin: OriginFor<T>, approve: bool) -> DispatchResultWithPostInfo {
 			let voter = ensure_signed(origin)?;
 
@@ -1024,7 +1035,7 @@ pub mod pallet {
 		///
 		/// Key: M (len of members), P (number of payouts for a particular member)
 		/// Total Complexity: O(M + logM + P + X)
-		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		#[pallet::weight(T::WeightInfo::payout())]
 		pub fn payout(origin: OriginFor<T>) -> DispatchResult {
 			let who = ensure_signed(origin)?;
 			ensure!(Members::<T, I>::get(&who).ok_or(Error::<T, I>::NotMember)?.rank == 0, Error::<T, I>::NoPayout);
@@ -1044,7 +1055,7 @@ pub mod pallet {
 
 		/// Repay the payment previously given to the member with the signed origin, remove any
 		/// pending payments, and elevate them from rank 0 to rank 1.
-		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		#[pallet::weight(T::WeightInfo::waive_repay())]
 		pub fn waive_repay(origin: OriginFor<T>, amount: BalanceOf<T, I>) -> DispatchResult {
 			let who = ensure_signed(origin)?;
 			let mut record = Members::<T, I>::get(&who).ok_or(Error::<T, I>::NotMember)?;
@@ -1080,7 +1091,7 @@ pub mod pallet {
 		/// - `rules` - The rules of this society concerning membership.
 		///
 		/// Complexity: O(1)
-		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		#[pallet::weight(T::WeightInfo::found_society())]
 		pub fn found_society(
 			origin: OriginFor<T>,
 			founder: T::AccountId,
@@ -1111,26 +1122,32 @@ pub mod pallet {
 		/// member.
 		///
 		/// Total Complexity: O(1)
-		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		#[pallet::weight(T::WeightInfo::dissolve())]
 		pub fn dissolve(origin: OriginFor<T>) -> DispatchResult {
 			let founder = ensure_signed(origin)?;
 			ensure!(Founder::<T, I>::get().as_ref() == Some(&founder), Error::<T, I>::NotFounder);
 			ensure!(MemberCount::<T, I>::get() == 1, Error::<T, I>::NotHead);
 
-			#[allow(deprecated)]
-			Members::<T, I>::remove_all(None);
+			let _ = Members::<T, I>::clear(u32::MAX, None);
 			MemberCount::<T, I>::kill();
-			#[allow(deprecated)]
-			MemberByIndex::<T, I>::remove_all(None);
-			#[allow(deprecated)]
-			Members::<T, I>::remove_all(None);
-			#[allow(deprecated)]
-			Votes::<T, I>::remove_all(None);
+			let _ = MemberByIndex::<T, I>::clear(u32::MAX, None);
+			let _ = SuspendedMembers::<T, I>::clear(u32::MAX, None);
+			let _ = Payouts::<T, I>::clear(u32::MAX, None);
+			let _ = Votes::<T, I>::clear(u32::MAX, None);
+			let _ = VoteClearCursor::<T, I>::clear(u32::MAX, None);
 			Head::<T, I>::kill();
+			NextHead::<T, I>::kill();
 			Founder::<T, I>::kill();
 			Rules::<T, I>::kill();
-			#[allow(deprecated)]
-			Candidates::<T, I>::remove_all(None);
+			Parameters::<T, I>::kill();
+			Pot::<T, I>::kill();
+			RoundCount::<T, I>::kill();
+			Bids::<T, I>::kill();
+			Skeptic::<T, I>::kill();
+			ChallengeRoundCount::<T, I>::kill();
+			Defending::<T, I>::kill();
+			let _ = DefenderVotes::<T, I>::clear(u32::MAX, None);
+			let _ = Candidates::<T, I>::clear(u32::MAX, None);
 			Self::deposit_event(Event::<T, I>::Unfounded { founder });
 			Ok(())
 		}
@@ -1152,17 +1169,14 @@ pub mod pallet {
 		///
 		/// Key: B (len of bids), M (len of members)
 		/// Total Complexity: O(M + logM + B)
-		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		#[pallet::weight(T::WeightInfo::judge_suspended_member())]
 		pub fn judge_suspended_member(
 			origin: OriginFor<T>,
 			who: T::AccountId,
 			forgive: bool,
 		) -> DispatchResultWithPostInfo {
-			let founder = ensure_signed(origin)?;
-			ensure!(Founder::<T, I>::get() == Some(founder.clone()), Error::<T, I>::NotFounder);
-
+			ensure!(Some(ensure_signed(origin)?) == Founder::<T, I>::get(), Error::<T, I>::NotFounder);
 			let record = SuspendedMembers::<T, I>::get(&who).ok_or(Error::<T, I>::NotSuspended)?;
-
 			if forgive {
 				// Try to add member back to society. Can fail with `MaxMembers` limit.
 				Self::reinstate_member(&who, record.rank)?;
@@ -1172,7 +1186,6 @@ pub mod pallet {
 					.map(|x| x.1).fold(Zero::zero(), |acc: BalanceOf<T, I>, x| acc.saturating_add(x));
 				Self::unreserve_payout(total);
 			}
-
 			SuspendedMembers::<T, I>::remove(&who);
 			Self::deposit_event(Event::<T, I>::SuspendedMemberJudgement { who, judged: forgive });
 			Ok(Pays::No.into())
@@ -1192,7 +1205,7 @@ pub mod pallet {
 		/// - `candidate_deposit`: The deposit required to make a bid for membership of the group.
 		///
 		/// Total Complexity: O(1)
-		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		#[pallet::weight(T::WeightInfo::set_parameters())]
 		pub fn set_parameters(
 			origin: OriginFor<T>,
 			max_members: u32,
@@ -1210,7 +1223,7 @@ pub mod pallet {
 
 		/// Punish the skeptic with a strike if they did not vote on a candidate. Callable by the
 		/// candidate.
-		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		#[pallet::weight(T::WeightInfo::punish_skeptic())]
 		pub fn punish_skeptic(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
 			let candidate = ensure_signed(origin)?;
 			let mut candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
@@ -1223,7 +1236,7 @@ pub mod pallet {
 
 		/// Transform an approved candidate into a member. Callable only by the
 		/// the candidate, and only after the period for voting has ended.
-		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		#[pallet::weight(T::WeightInfo::claim_membership())]
 		pub fn claim_membership(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
 			let candidate = ensure_signed(origin)?;
 			let candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
@@ -1236,10 +1249,9 @@ pub mod pallet {
 		/// Transform an approved candidate into a member. Callable only by the Signed origin of the
 		/// Founder, only after the period for voting has ended and only when the candidate is not
 		/// clearly rejected.
-		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		#[pallet::weight(T::WeightInfo::bestow_membership())]
 		pub fn bestow_membership(origin: OriginFor<T>, candidate: T::AccountId) -> DispatchResultWithPostInfo {
-			let founder = ensure_signed(origin)?;
-			ensure!(Founder::<T, I>::get() == Some(founder.clone()), Error::<T, I>::NotFounder);
+			ensure!(Some(ensure_signed(origin)?) == Founder::<T, I>::get(), Error::<T, I>::NotFounder);
 			let candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
 			ensure!(!candidacy.tally.clear_rejection(), Error::<T, I>::Rejected);
 			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
@@ -1252,10 +1264,9 @@ pub mod pallet {
 		/// have a clear approval.
 		///
 		/// Any bid deposit is lost and voucher is banned.
-		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		#[pallet::weight(T::WeightInfo::kick_candidate())]
 		pub fn kick_candidate(origin: OriginFor<T>, candidate: T::AccountId) -> DispatchResultWithPostInfo {
-			let founder = ensure_signed(origin)?;
-			ensure!(Founder::<T, I>::get() == Some(founder.clone()), Error::<T, I>::NotFounder);
+			ensure!(Some(ensure_signed(origin)?) == Founder::<T, I>::get(), Error::<T, I>::NotFounder);
 			let mut candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
 			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
 			ensure!(!candidacy.tally.clear_approval(), Error::<T, I>::Approved);
@@ -1268,7 +1279,7 @@ pub mod pallet {
 		/// Remove the candidate's application from the society. Callable only by the candidate.
 		///
 		/// Any bid deposit is lost and voucher is banned.
-		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		#[pallet::weight(T::WeightInfo::resign_candidacy())]
 		pub fn resign_candidacy(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
 			let candidate = ensure_signed(origin)?;
 			let mut candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
@@ -1285,7 +1296,7 @@ pub mod pallet {
 		/// a candidate with more rejections than approvals.
 		///
 		/// The bid deposit is lost and the voucher is banned.
-		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		#[pallet::weight(T::WeightInfo::drop_candidate())]
 		pub fn drop_candidate(origin: OriginFor<T>, candidate: T::AccountId) -> DispatchResultWithPostInfo {
 			ensure_signed(origin)?;
 			let candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
@@ -1299,20 +1310,22 @@ pub mod pallet {
 		/// Remove up to `max` stale votes for the given `candidate`.
 		///
 		/// May be called by any Signed origin, but only after the candidate's candidacy is ended.
-		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		#[pallet::weight(T::WeightInfo::cleanup_candidacy())]
 		pub fn cleanup_candidacy(origin: OriginFor<T>, candidate: T::AccountId, max: u32) -> DispatchResultWithPostInfo {
 			ensure_signed(origin)?;
 			ensure!(!Candidates::<T, I>::contains_key(&candidate), Error::<T, I>::InProgress);
 			let maybe_cursor = VoteClearCursor::<T, I>::get(&candidate);
-			let r = Votes::<T, I>::clear_prefix(&candidate, Some(max), maybe_cursor.as_ref().map(|x| &x[..]));
-			VoteClearCursor::<T, I>::set(&candidate, r.maybe_cursor.map(BoundedVec::truncate_from));
+			let r = Votes::<T, I>::clear_prefix(&candidate, max, maybe_cursor.as_ref().map(|x| &x[..]));
+			if let Some(cursor) = r.maybe_cursor {
+				VoteClearCursor::<T, I>::insert(&candidate, BoundedVec::truncate_from(cursor));
+			}
 			Ok(if r.loops == 0 { Pays::Yes } else { Pays::No }.into())
 		}
 
 		/// Remove up to `max` stale votes for the defender in the given `challenge_round`.
 		///
 		/// May be called by any Signed origin, but only after the challenge round is ended.
-		#[pallet::weight(T::BlockWeights::get().max_block / 10)]
+		#[pallet::weight(T::WeightInfo::cleanup_challenge())]
 		pub fn cleanup_challenge(
 			origin: OriginFor<T>,
 			challenge_round: RoundIndex,
@@ -1320,10 +1333,11 @@ pub mod pallet {
 		) -> DispatchResultWithPostInfo {
 			ensure_signed(origin)?;
 			ensure!(challenge_round < ChallengeRoundCount::<T, I>::get(), Error::<T, I>::InProgress);
-			match DefenderVotes::<T, I>::remove_prefix(challenge_round, Some(max)) {
-				KillStorageResult::AllRemoved(0) => Err(Error::<T, I>::NoVotes.into()),
-				_ => Ok(Pays::No.into()),
-			}
+			let _ = DefenderVotes::<T, I>::clear_prefix(challenge_round, max, None);
+			// clear_prefix() v2 is always returning backend = 0, ignoring it till v3.
+			// let (_, backend, _, _) = r.deconstruct();
+			// if backend == 0 { return Err(Error::<T, I>::NoVotes.into()); };
+			Ok(Pays::No.into())
 		}
 	}
 }
@@ -1370,7 +1384,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		let voting_period = T::VotingPeriod::get();
 		let rotation_period = voting_period + claim_period;
 		let now = frame_system::Pallet::<T>::block_number();
-		let phase = now % rotation_period;
+		let phase = now % rotation_period.clone();
 		if phase < voting_period {
 			Period::Voting { elapsed: phase, more: voting_period - phase }
 		} else {
@@ -1664,7 +1678,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	) -> DispatchResult {
 		Self::add_new_member(&candidate, rank)?;
 		Self::check_skeptic(&candidate, &mut candidacy);
-		
+
 		let next_head = NextHead::<T, I>::get()
 			.filter(|old| {
 				old.round > candidacy.round
diff --git a/frame/society/src/migrations.rs b/frame/society/src/migrations.rs
index eb5a8f2019167..29d4bea461a9b 100644
--- a/frame/society/src/migrations.rs
+++ b/frame/society/src/migrations.rs
@@ -229,11 +229,11 @@ pub fn from_original<
 	}
 
 	// Any suspended candidates remaining are rejected.
-	old::SuspendedCandidates::<T, I>::remove_all(None);
+	let _ = old::SuspendedCandidates::<T, I>::clear(u32::MAX, None);
 
 	// We give the current defender the benefit of the doubt.
 	old::Defender::<T, I>::kill();
-	old::DefenderVotes::<T, I>::remove_all(None);
+	let _ = old::DefenderVotes::<T, I>::clear(u32::MAX, None);
 }
 
 pub fn from_raw_past_payouts<
diff --git a/frame/society/src/mock.rs b/frame/society/src/mock.rs
index 10404cbae1e0f..ea7d82f34cfc9 100644
--- a/frame/society/src/mock.rs
+++ b/frame/society/src/mock.rs
@@ -54,8 +54,12 @@ parameter_types! {
 }
 
 ord_parameter_types! {
+	pub const ChallengePeriod: u64 = 8;
+	pub const ClaimPeriod: u64 = 1;
 	pub const FounderSetAccount: u128 = 1;
 	pub const SuspensionJudgementSetAccount: u128 = 2;
+	pub const MaxPayouts: u32 = 10;
+	pub const MaxBids: u32 = 10;
 }
 
 impl frame_system::Config for Test {
@@ -105,12 +109,13 @@ impl Config for Test {
 	type GraceStrikes = ConstU32<1>;
 	type PeriodSpend = ConstU64<1000>;
 	type VotingPeriod = ConstU64<3>;
-	type ClaimPeriod = ConstU64<1>;
+	type ClaimPeriod = ClaimPeriod;
 	type MaxLockDuration = ConstU64<100>;
 	type FounderSetOrigin = EnsureSignedBy<FounderSetAccount, u128>;
-	type ChallengePeriod = ConstU64<8>;
-	type MaxPayouts = ConstU32<10>;
-	type MaxBids = ConstU32<10>;
+	type ChallengePeriod = ChallengePeriod;
+	type MaxPayouts = MaxPayouts;
+	type MaxBids = MaxBids;
+	type WeightInfo = ();
 }
 
 pub struct EnvBuilder {
diff --git a/frame/society/src/tests.rs b/frame/society/src/tests.rs
index 49ddf4bc264f8..55da8e05d0395 100644
--- a/frame/society/src/tests.rs
+++ b/frame/society/src/tests.rs
@@ -1129,3 +1129,71 @@ fn bids_ordered_correctly() {
 		assert_eq!(Bids::<Test>::get(), final_list);
 	});
 }
+
+#[test]
+fn waive_repay_works() {
+	EnvBuilder::new().execute(|| {
+		place_members([20, 30]);
+		Society::bump_payout(&20, 5, 100);
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() }
+		);
+		assert_eq!(Members::<Test>::get(20).unwrap().rank, 0);
+		assert_ok!(Society::waive_repay(Origin::signed(20), 100));
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![].try_into().unwrap() }
+		);
+		assert_eq!(Members::<Test>::get(10).unwrap().rank, 1);
+		assert_eq!(Balances::free_balance(20), 50);
+	});
+}
+
+#[test]
+fn punish_skeptic_works() {
+	EnvBuilder::new().execute(|| {
+		place_members([20]);
+		assert_ok!(Society::bid(Origin::signed(30), 0));
+		next_intake();
+		// Force 20 to be Skeptic so it gets a strike.
+		Skeptic::<Test>::put(20);
+		next_voting();
+		// 30 decides to punish the skeptic (20).
+		assert_ok!(Society::punish_skeptic(Origin::signed(30)));
+		// 20 gets 1 strike.
+		assert_eq!(Members::<Test>::get(20).unwrap().strikes, 1);
+		let candidacy = Candidates::<Test>::get(&30).unwrap();
+		// 30 candidacy has changed.
+		assert_eq!(candidacy.skeptic_struck, true);
+	});
+}
+
+#[test]
+fn resign_candidacy_works() {
+	EnvBuilder::new().execute(|| {
+		assert_ok!(Society::bid(Origin::signed(30), 45));
+		next_intake();
+		assert_eq!(candidates(), vec![30]);
+		assert_ok!(Society::resign_candidacy(Origin::signed(30)));
+		// 30 candidacy has gone.
+		assert_eq!(candidates(), vec![]);
+	});
+}
+
+#[test]
+fn drop_candidate_works() {
+	EnvBuilder::new().execute(|| {
+		place_members([20, 30]);
+		assert_ok!(Society::bid(Origin::signed(40), 45));
+		next_intake();
+		assert_eq!(candidates(), vec![40]);
+		assert_ok!(Society::vote(Origin::signed(10), 40, false));
+		assert_ok!(Society::vote(Origin::signed(20), 40, false));
+		assert_ok!(Society::vote(Origin::signed(30), 40, false));
+		run_to_block(12);
+		assert_ok!(Society::drop_candidate(Origin::signed(50), 40));
+		// 40 candidacy has gone.
+		assert_eq!(candidates(), vec![]);
+	});
+}
diff --git a/frame/society/src/weights.rs b/frame/society/src/weights.rs
new file mode 100644
index 0000000000000..dc9e0d3471692
--- /dev/null
+++ b/frame/society/src/weights.rs
@@ -0,0 +1,454 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2022 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Autogenerated weights for pallet_society
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2022-09-13, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_society
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --template=./.maintain/frame-weight-template.hbs
+// --output=./frame/society/src/weights.rs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use sp_std::marker::PhantomData;
+
+/// Weight functions needed for pallet_society.
+pub trait WeightInfo {
+	fn bid() -> Weight;
+	fn unbid() -> Weight;
+	fn vouch() -> Weight;
+	fn unvouch() -> Weight;
+	fn vote() -> Weight;
+	fn defender_vote() -> Weight;
+	fn payout() -> Weight;
+	fn waive_repay() -> Weight;
+	fn found_society() -> Weight;
+	fn dissolve() -> Weight;
+	fn judge_suspended_member() -> Weight;
+	fn set_parameters() -> Weight;
+	fn punish_skeptic() -> Weight;
+	fn claim_membership() -> Weight;
+	fn bestow_membership() -> Weight;
+	fn kick_candidate() -> Weight;
+	fn resign_candidacy() -> Weight;
+	fn drop_candidate() -> Weight;
+	fn cleanup_candidacy() -> Weight;
+	fn cleanup_challenge() -> Weight;
+}
+
+/// Weights for pallet_society using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	// Storage: Society Bids (r:1 w:1)
+	// Storage: Society Candidates (r:1 w:0)
+	// Storage: Society Members (r:1 w:0)
+	// Storage: Society SuspendedMembers (r:1 w:0)
+	// Storage: Society Parameters (r:1 w:0)
+	fn bid() -> Weight {
+		(56_738_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(5 as Weight))
+			.saturating_add(T::DbWeight::get().writes(1 as Weight))
+	}
+	// Storage: Society Bids (r:1 w:1)
+	fn unbid() -> Weight {
+		(45_204_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(1 as Weight))
+			.saturating_add(T::DbWeight::get().writes(1 as Weight))
+	}
+	// Storage: Society Bids (r:1 w:1)
+	// Storage: Society Candidates (r:1 w:0)
+	// Storage: Society Members (r:2 w:1)
+	// Storage: Society SuspendedMembers (r:1 w:0)
+	fn vouch() -> Weight {
+		(43_566_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(5 as Weight))
+			.saturating_add(T::DbWeight::get().writes(2 as Weight))
+	}
+	// Storage: Society Bids (r:1 w:1)
+	// Storage: Society Members (r:1 w:1)
+	fn unvouch() -> Weight {
+		(33_741_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(2 as Weight))
+			.saturating_add(T::DbWeight::get().writes(2 as Weight))
+	}
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society Members (r:1 w:0)
+	// Storage: Society Votes (r:1 w:1)
+	fn vote() -> Weight {
+		(44_890_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(3 as Weight))
+			.saturating_add(T::DbWeight::get().writes(2 as Weight))
+	}
+	// Storage: Society Defending (r:1 w:1)
+	// Storage: Society Members (r:1 w:0)
+	// Storage: Society ChallengeRoundCount (r:1 w:0)
+	// Storage: Society DefenderVotes (r:1 w:1)
+	fn defender_vote() -> Weight {
+		(41_752_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(4 as Weight))
+			.saturating_add(T::DbWeight::get().writes(2 as Weight))
+	}
+	// Storage: Society Members (r:1 w:0)
+	// Storage: Society Payouts (r:1 w:1)
+	// Storage: System Account (r:1 w:1)
+	fn payout() -> Weight {
+		(58_145_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(3 as Weight))
+			.saturating_add(T::DbWeight::get().writes(2 as Weight))
+	}
+	// Storage: Society Members (r:1 w:1)
+	// Storage: Society Payouts (r:1 w:1)
+	fn waive_repay() -> Weight {
+		(37_796_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(2 as Weight))
+			.saturating_add(T::DbWeight::get().writes(2 as Weight))
+	}
+	// Storage: Society Head (r:1 w:1)
+	// Storage: Society MemberCount (r:1 w:1)
+	// Storage: Society MemberByIndex (r:0 w:1)
+	// Storage: Society Founder (r:0 w:1)
+	// Storage: Society Rules (r:0 w:1)
+	// Storage: Society Members (r:0 w:1)
+	// Storage: Society Parameters (r:0 w:1)
+	fn found_society() -> Weight {
+		(37_221_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(2 as Weight))
+			.saturating_add(T::DbWeight::get().writes(7 as Weight))
+	}
+	// Storage: Society Founder (r:1 w:1)
+	// Storage: Society MemberCount (r:1 w:1)
+	// Storage: Society Head (r:0 w:1)
+	// Storage: Society Defending (r:0 w:1)
+	// Storage: Society ChallengeRoundCount (r:0 w:1)
+	// Storage: Society MemberByIndex (r:0 w:5)
+	// Storage: Society Skeptic (r:0 w:1)
+	// Storage: Society Candidates (r:0 w:4)
+	// Storage: Society Pot (r:0 w:1)
+	// Storage: Society Rules (r:0 w:1)
+	// Storage: Society Votes (r:0 w:4)
+	// Storage: Society Members (r:0 w:5)
+	// Storage: Society RoundCount (r:0 w:1)
+	// Storage: Society Bids (r:0 w:1)
+	// Storage: Society Parameters (r:0 w:1)
+	// Storage: Society NextHead (r:0 w:1)
+	fn dissolve() -> Weight {
+		(105_209_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(2 as Weight))
+			.saturating_add(T::DbWeight::get().writes(30 as Weight))
+	}
+	// Storage: Society Founder (r:1 w:0)
+	// Storage: Society SuspendedMembers (r:1 w:1)
+	// Storage: Society Payouts (r:1 w:0)
+	// Storage: Society Pot (r:1 w:1)
+	fn judge_suspended_member() -> Weight {
+		(39_916_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(4 as Weight))
+			.saturating_add(T::DbWeight::get().writes(2 as Weight))
+	}
+	// Storage: Society Founder (r:1 w:0)
+	// Storage: Society MemberCount (r:1 w:0)
+	// Storage: Society Parameters (r:0 w:1)
+	fn set_parameters() -> Weight {
+		(28_251_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(2 as Weight))
+			.saturating_add(T::DbWeight::get().writes(1 as Weight))
+	}
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society RoundCount (r:1 w:0)
+	// Storage: Society Skeptic (r:1 w:0)
+	// Storage: Society Votes (r:1 w:0)
+	// Storage: Society Members (r:1 w:1)
+	// Storage: Society Parameters (r:1 w:0)
+	fn punish_skeptic() -> Weight {
+		(40_041_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(6 as Weight))
+			.saturating_add(T::DbWeight::get().writes(2 as Weight))
+	}
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society RoundCount (r:1 w:0)
+	// Storage: Society Parameters (r:1 w:0)
+	// Storage: Society MemberCount (r:1 w:1)
+	// Storage: Society NextHead (r:1 w:1)
+	// Storage: System Account (r:1 w:1)
+	// Storage: Society MemberByIndex (r:0 w:1)
+	// Storage: Society Members (r:0 w:1)
+	fn claim_membership() -> Weight {
+		(64_305_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(6 as Weight))
+			.saturating_add(T::DbWeight::get().writes(6 as Weight))
+	}
+	// Storage: Society Founder (r:1 w:0)
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society RoundCount (r:1 w:0)
+	// Storage: Society Parameters (r:1 w:0)
+	// Storage: Society MemberCount (r:1 w:1)
+	// Storage: Society NextHead (r:1 w:1)
+	// Storage: System Account (r:1 w:1)
+	// Storage: Society MemberByIndex (r:0 w:1)
+	// Storage: Society Members (r:0 w:1)
+	fn bestow_membership() -> Weight {
+		(68_334_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(7 as Weight))
+			.saturating_add(T::DbWeight::get().writes(6 as Weight))
+	}
+	// Storage: Society Founder (r:1 w:0)
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society RoundCount (r:1 w:0)
+	fn kick_candidate() -> Weight {
+		(23_574_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(3 as Weight))
+			.saturating_add(T::DbWeight::get().writes(1 as Weight))
+	}
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society RoundCount (r:1 w:0)
+	fn resign_candidacy() -> Weight {
+		(22_284_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(2 as Weight))
+			.saturating_add(T::DbWeight::get().writes(1 as Weight))
+	}
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society RoundCount (r:1 w:0)
+	fn drop_candidate() -> Weight {
+		(32_618_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(2 as Weight))
+			.saturating_add(T::DbWeight::get().writes(1 as Weight))
+	}
+	// Storage: Society Candidates (r:1 w:0)
+	// Storage: Society VoteClearCursor (r:1 w:0)
+	// Storage: Society Votes (r:0 w:2)
+	fn cleanup_candidacy() -> Weight {
+		(27_936_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(2 as Weight))
+			.saturating_add(T::DbWeight::get().writes(2 as Weight))
+	}
+	// Storage: Society ChallengeRoundCount (r:1 w:0)
+	// Storage: Society DefenderVotes (r:0 w:1)
+	fn cleanup_challenge() -> Weight {
+		(18_411_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(1 as Weight))
+			.saturating_add(T::DbWeight::get().writes(1 as Weight))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	// Storage: Society Bids (r:1 w:1)
+	// Storage: Society Candidates (r:1 w:0)
+	// Storage: Society Members (r:1 w:0)
+	// Storage: Society SuspendedMembers (r:1 w:0)
+	// Storage: Society Parameters (r:1 w:0)
+	fn bid() -> Weight {
+		(56_738_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(5 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
+	}
+	// Storage: Society Bids (r:1 w:1)
+	fn unbid() -> Weight {
+		(45_204_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
+	}
+	// Storage: Society Bids (r:1 w:1)
+	// Storage: Society Candidates (r:1 w:0)
+	// Storage: Society Members (r:2 w:1)
+	// Storage: Society SuspendedMembers (r:1 w:0)
+	fn vouch() -> Weight {
+		(43_566_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(5 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
+	}
+	// Storage: Society Bids (r:1 w:1)
+	// Storage: Society Members (r:1 w:1)
+	fn unvouch() -> Weight {
+		(33_741_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
+	}
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society Members (r:1 w:0)
+	// Storage: Society Votes (r:1 w:1)
+	fn vote() -> Weight {
+		(44_890_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
+	}
+	// Storage: Society Defending (r:1 w:1)
+	// Storage: Society Members (r:1 w:0)
+	// Storage: Society ChallengeRoundCount (r:1 w:0)
+	// Storage: Society DefenderVotes (r:1 w:1)
+	fn defender_vote() -> Weight {
+		(41_752_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(4 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
+	}
+	// Storage: Society Members (r:1 w:0)
+	// Storage: Society Payouts (r:1 w:1)
+	// Storage: System Account (r:1 w:1)
+	fn payout() -> Weight {
+		(58_145_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
+	}
+	// Storage: Society Members (r:1 w:1)
+	// Storage: Society Payouts (r:1 w:1)
+	fn waive_repay() -> Weight {
+		(37_796_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
+	}
+	// Storage: Society Head (r:1 w:1)
+	// Storage: Society MemberCount (r:1 w:1)
+	// Storage: Society MemberByIndex (r:0 w:1)
+	// Storage: Society Founder (r:0 w:1)
+	// Storage: Society Rules (r:0 w:1)
+	// Storage: Society Members (r:0 w:1)
+	// Storage: Society Parameters (r:0 w:1)
+	fn found_society() -> Weight {
+		(37_221_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(7 as Weight))
+	}
+	// Storage: Society Founder (r:1 w:1)
+	// Storage: Society MemberCount (r:1 w:1)
+	// Storage: Society Head (r:0 w:1)
+	// Storage: Society Defending (r:0 w:1)
+	// Storage: Society ChallengeRoundCount (r:0 w:1)
+	// Storage: Society MemberByIndex (r:0 w:5)
+	// Storage: Society Skeptic (r:0 w:1)
+	// Storage: Society Candidates (r:0 w:4)
+	// Storage: Society Pot (r:0 w:1)
+	// Storage: Society Rules (r:0 w:1)
+	// Storage: Society Votes (r:0 w:4)
+	// Storage: Society Members (r:0 w:5)
+	// Storage: Society RoundCount (r:0 w:1)
+	// Storage: Society Bids (r:0 w:1)
+	// Storage: Society Parameters (r:0 w:1)
+	// Storage: Society NextHead (r:0 w:1)
+	fn dissolve() -> Weight {
+		(105_209_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(30 as Weight))
+	}
+	// Storage: Society Founder (r:1 w:0)
+	// Storage: Society SuspendedMembers (r:1 w:1)
+	// Storage: Society Payouts (r:1 w:0)
+	// Storage: Society Pot (r:1 w:1)
+	fn judge_suspended_member() -> Weight {
+		(39_916_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(4 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
+	}
+	// Storage: Society Founder (r:1 w:0)
+	// Storage: Society MemberCount (r:1 w:0)
+	// Storage: Society Parameters (r:0 w:1)
+	fn set_parameters() -> Weight {
+		(28_251_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
+	}
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society RoundCount (r:1 w:0)
+	// Storage: Society Skeptic (r:1 w:0)
+	// Storage: Society Votes (r:1 w:0)
+	// Storage: Society Members (r:1 w:1)
+	// Storage: Society Parameters (r:1 w:0)
+	fn punish_skeptic() -> Weight {
+		(40_041_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(6 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
+	}
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society RoundCount (r:1 w:0)
+	// Storage: Society Parameters (r:1 w:0)
+	// Storage: Society MemberCount (r:1 w:1)
+	// Storage: Society NextHead (r:1 w:1)
+	// Storage: System Account (r:1 w:1)
+	// Storage: Society MemberByIndex (r:0 w:1)
+	// Storage: Society Members (r:0 w:1)
+	fn claim_membership() -> Weight {
+		(64_305_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(6 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(6 as Weight))
+	}
+	// Storage: Society Founder (r:1 w:0)
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society RoundCount (r:1 w:0)
+	// Storage: Society Parameters (r:1 w:0)
+	// Storage: Society MemberCount (r:1 w:1)
+	// Storage: Society NextHead (r:1 w:1)
+	// Storage: System Account (r:1 w:1)
+	// Storage: Society MemberByIndex (r:0 w:1)
+	// Storage: Society Members (r:0 w:1)
+	fn bestow_membership() -> Weight {
+		(68_334_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(7 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(6 as Weight))
+	}
+	// Storage: Society Founder (r:1 w:0)
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society RoundCount (r:1 w:0)
+	fn kick_candidate() -> Weight {
+		(23_574_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
+	}
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society RoundCount (r:1 w:0)
+	fn resign_candidacy() -> Weight {
+		(22_284_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
+	}
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society RoundCount (r:1 w:0)
+	fn drop_candidate() -> Weight {
+		(32_618_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
+	}
+	// Storage: Society Candidates (r:1 w:0)
+	// Storage: Society VoteClearCursor (r:1 w:0)
+	// Storage: Society Votes (r:0 w:2)
+	fn cleanup_candidacy() -> Weight {
+		(27_936_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
+	}
+	// Storage: Society ChallengeRoundCount (r:1 w:0)
+	// Storage: Society DefenderVotes (r:0 w:1)
+	fn cleanup_challenge() -> Weight {
+		(18_411_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
+	}
+}
diff --git a/frame/system/src/lib.rs b/frame/system/src/lib.rs
index cbbaee75149e9..370a802665918 100644
--- a/frame/system/src/lib.rs
+++ b/frame/system/src/lib.rs
@@ -197,7 +197,6 @@ impl<MaxNormal: Get<u32>, MaxOverflow: Get<u32>> ConsumerLimits for (MaxNormal,
 pub mod pallet {
 	use crate::{self as frame_system, pallet_prelude::*, *};
 	use frame_support::pallet_prelude::*;
-	use sp_core::crypto::FromEntropy;
 
 	/// System configuration trait. Implemented by runtime.
 	#[pallet::config]
@@ -278,8 +277,7 @@ pub mod pallet {
 			+ Debug
 			+ MaybeDisplay
 			+ Ord
-			+ MaxEncodedLen
-			+ FromEntropy;
+			+ MaxEncodedLen;
 
 		/// Converting trait to take a source type and convert to `AccountId`.
 		///

From 3f20f3666e37871a20ad95674461989f5794daba Mon Sep 17 00:00:00 2001
From: Gav <gavin@parity.io>
Date: Mon, 5 Dec 2022 12:38:21 +0000
Subject: [PATCH 25/43] Fix Cargo

---
 Cargo.lock               | 6 ++++++
 frame/society/Cargo.toml | 4 ++--
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 594b3083f2a0b..4e5d1d25eab47 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2872,6 +2872,12 @@ version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
+[[package]]
+name = "hex-literal"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ebdb29d2ea9ed0083cd8cece49bbd968021bd99b0849edb4a9a7ee0fdf6a4e0"
+
 [[package]]
 name = "hmac"
 version = "0.8.1"
diff --git a/frame/society/Cargo.toml b/frame/society/Cargo.toml
index ee40395c75ac1..6b5eb0fce31b6 100644
--- a/frame/society/Cargo.toml
+++ b/frame/society/Cargo.toml
@@ -18,8 +18,8 @@ rand_chacha = { version = "0.2", default-features = false }
 scale-info = { version = "2.1.1", default-features = false, features = ["derive"] }
 sp-runtime = { version = "7.0.0", default-features = false, path = "../../primitives/runtime" }
 sp-std = { version = "5.0.0", default-features = false, path = "../../primitives/std" }
-sp-io = { version = "6.0.0", default-features = false, path = "../../primitives/io" }
-sp-arithmetic = { version = "5.0.0", default-features = false, path = "../../primitives/arithmetic" }
+sp-io = { version = "7.0.0", default-features = false, path = "../../primitives/io" }
+sp-arithmetic = { version = "6.0.0", default-features = false, path = "../../primitives/arithmetic" }
 frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
 frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
 frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }

From db9990f3edfb67803f7e29049b5214f21cd44fae Mon Sep 17 00:00:00 2001
From: Gav <gavin@parity.io>
Date: Wed, 7 Dec 2022 16:02:53 +0000
Subject: [PATCH 26/43] Fixes

---
 frame/society/src/lib.rs               | 275 ++++++++++++++++---------
 frame/society/src/migrations.rs        | 113 +++++-----
 frame/society/src/mock.rs              |  28 ++-
 frame/society/src/tests.rs             | 268 ++++++++++++++++--------
 frame/society/src/weights.rs           | 160 ++++----------
 frame/support/src/storage/mod.rs       |   9 +-
 frame/support/src/storage/types/map.rs |   8 +-
 primitives/core/src/ed25519.rs         |   4 +-
 primitives/core/src/sr25519.rs         |   4 +-
 9 files changed, 483 insertions(+), 386 deletions(-)

diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index 2187759a35ba2..0e848dfa949e7 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -261,8 +261,8 @@ use frame_support::{
 	pallet_prelude::*,
 	storage::KeyLenOf,
 	traits::{
-		Currency, EnsureOrigin, ExistenceRequirement::AllowDeath,
-		Imbalance, OnUnbalanced, Randomness, ReservableCurrency, BalanceStatus,
+		BalanceStatus, Currency, EnsureOrigin, ExistenceRequirement::AllowDeath, Imbalance,
+		OnUnbalanced, Randomness, ReservableCurrency,
 	},
 	PalletId,
 };
@@ -274,10 +274,11 @@ use rand_chacha::{
 use scale_info::TypeInfo;
 use sp_runtime::{
 	traits::{
-		AccountIdConversion, CheckedAdd, CheckedSub, Hash, Saturating,
-		StaticLookup, TrailingZeroInput, Zero,
+		AccountIdConversion, CheckedAdd, CheckedSub, Hash, Saturating, StaticLookup,
+		TrailingZeroInput, Zero,
 	},
-	ArithmeticError::Overflow, Percent, RuntimeDebug,
+	ArithmeticError::Overflow,
+	Percent, RuntimeDebug,
 };
 use sp_std::prelude::*;
 
@@ -450,10 +451,8 @@ pub struct IntakeRecord<AccountId, Balance> {
 	round: RoundIndex,
 }
 
-pub type IntakeRecordFor<T, I> = IntakeRecord<
-	<T as frame_system::Config>::AccountId,
-	BalanceOf<T, I>,
->;
+pub type IntakeRecordFor<T, I> =
+	IntakeRecord<<T as frame_system::Config>::AccountId, BalanceOf<T, I>>;
 
 #[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
 pub struct GroupParams<Balance> {
@@ -658,7 +657,8 @@ pub mod pallet {
 
 	/// The max number of members for the society at one time.
 	#[pallet::storage]
-	pub(super) type Parameters<T: Config<I>, I: 'static = ()> = StorageValue<_, GroupParamsFor<T, I>, OptionQuery>;
+	pub(super) type Parameters<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, GroupParamsFor<T, I>, OptionQuery>;
 
 	/// Amount of our account balance that is specifically for the next round's bid(s).
 	#[pallet::storage]
@@ -712,7 +712,8 @@ pub mod pallet {
 		StorageValue<_, BoundedVec<Bid<T::AccountId, BalanceOf<T, I>>, T::MaxBids>, ValueQuery>;
 
 	#[pallet::storage]
-	pub type Candidates<T: Config<I>, I: 'static = ()> = StorageMap<_,
+	pub type Candidates<T: Config<I>, I: 'static = ()> = StorageMap<
+		_,
 		Blake2_128Concat,
 		T::AccountId,
 		Candidacy<T::AccountId, BalanceOf<T, I>>,
@@ -725,7 +726,8 @@ pub mod pallet {
 
 	/// Double map from Candidate -> Voter -> (Maybe) Vote.
 	#[pallet::storage]
-	pub(super) type Votes<T: Config<I>, I: 'static = ()> = StorageDoubleMap<_,
+	pub(super) type Votes<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
+		_,
 		Twox64Concat,
 		T::AccountId,
 		Twox64Concat,
@@ -736,28 +738,25 @@ pub mod pallet {
 
 	/// Clear-cursor for Vote, map from Candidate -> (Maybe) Cursor.
 	#[pallet::storage]
-	pub(super) type VoteClearCursor<T: Config<I>, I: 'static = ()> = StorageMap<_,
-		Twox64Concat,
-		T::AccountId,
-		BoundedVec<u8, KeyLenOf<Votes<T, I>>>
-	>;
+	pub(super) type VoteClearCursor<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Twox64Concat, T::AccountId, BoundedVec<u8, KeyLenOf<Votes<T, I>>>>;
 
 	/// At the end of the claim period, this contains the most recently approved members (along with
 	/// their bid and round ID) who is from the most recent round with the lowest bid. They will
 	/// become the new `Head`.
 	#[pallet::storage]
-	pub type NextHead<T: Config<I>, I: 'static = ()> = StorageValue<_,
-		IntakeRecordFor<T, I>,
-		OptionQuery,
-	>;
+	pub type NextHead<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, IntakeRecordFor<T, I>, OptionQuery>;
 
 	/// The number of challenge rounds there have been. Used to identify stale DefenderVotes.
 	#[pallet::storage]
-	pub(super) type ChallengeRoundCount<T: Config<I>, I: 'static = ()> = StorageValue<_, RoundIndex, ValueQuery>;
+	pub(super) type ChallengeRoundCount<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, RoundIndex, ValueQuery>;
 
 	/// The defending member currently being challenged, along with a running tally of votes.
 	#[pallet::storage]
-	pub(super) type Defending<T: Config<I>, I: 'static = ()> = StorageValue<_, (T::AccountId, T::AccountId, Tally)>;
+	pub(super) type Defending<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, (T::AccountId, T::AccountId, Tally)>;
 
 	/// Votes for the defender, keyed by challenge round.
 	#[pallet::storage]
@@ -767,7 +766,7 @@ pub mod pallet {
 	#[pallet::hooks]
 	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {
 		fn on_initialize(n: T::BlockNumber) -> Weight {
-			let mut weight = 0;
+			let mut weight = Weight::zero();
 			let weights = T::BlockWeights::get();
 
 			let phrase = b"society_rotation";
@@ -784,15 +783,15 @@ pub mod pallet {
 			match Self::period() {
 				Period::Voting { elapsed, .. } if elapsed.is_zero() => {
 					Self::rotate_intake(&mut rng);
-					weight += weights.max_block / 20;
+					weight.saturating_accrue(weights.max_block / 20);
 				},
-				_ => {}
+				_ => {},
 			}
 
 			// Run a challenge rotation
 			if (n % T::ChallengePeriod::get()).is_zero() {
 				Self::rotate_challenge(&mut rng);
-				weight += weights.max_block / 20;
+				weight.saturating_accrue(weights.max_block / 20);
 			}
 
 			weight
@@ -807,9 +806,7 @@ pub mod pallet {
 	#[cfg(feature = "std")]
 	impl<T: Config<I>, I: 'static> Default for GenesisConfig<T, I> {
 		fn default() -> Self {
-			Self {
-				pot: Default::default(),
-			}
+			Self { pot: Default::default() }
 		}
 	}
 
@@ -905,6 +902,7 @@ pub mod pallet {
 			tip: BalanceOf<T, I>,
 		) -> DispatchResult {
 			let voucher = ensure_signed(origin)?;
+			let who = T::Lookup::lookup(who)?;
 
 			// Get bids and check user is not bidding.
 			let mut bids = Bids::<T, I>::get();
@@ -950,7 +948,9 @@ pub mod pallet {
 			let voucher = ensure_signed(origin)?;
 
 			let mut bids = Bids::<T, I>::get();
-			let pos = bids.iter().position(|bid| bid.kind.is_vouch(&voucher))
+			let pos = bids
+				.iter()
+				.position(|bid| bid.kind.is_vouch(&voucher))
 				.ok_or(Error::<T, I>::NotVouchingOnBidder)?;
 			let bid = bids.remove(pos);
 			Self::clean_bid(&bid);
@@ -980,7 +980,8 @@ pub mod pallet {
 			let voter = ensure_signed(origin)?;
 			let candidate = T::Lookup::lookup(candidate)?;
 
-			let mut candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			let mut candidacy =
+				Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
 			let record = Members::<T, I>::get(&voter).ok_or(Error::<T, I>::NotMember)?;
 
 			let first_time = Votes::<T, I>::mutate(&candidate, &voter, |v| {
@@ -1040,7 +1041,10 @@ pub mod pallet {
 		#[pallet::weight(T::WeightInfo::payout())]
 		pub fn payout(origin: OriginFor<T>) -> DispatchResult {
 			let who = ensure_signed(origin)?;
-			ensure!(Members::<T, I>::get(&who).ok_or(Error::<T, I>::NotMember)?.rank == 0, Error::<T, I>::NoPayout);
+			ensure!(
+				Members::<T, I>::get(&who).ok_or(Error::<T, I>::NotMember)?.rank == 0,
+				Error::<T, I>::NoPayout
+			);
 			let mut record = Payouts::<T, I>::get(&who);
 
 			if let Some((when, amount)) = record.payouts.first() {
@@ -1104,6 +1108,7 @@ pub mod pallet {
 			rules: Vec<u8>,
 		) -> DispatchResult {
 			T::FounderSetOrigin::ensure_origin(origin)?;
+			let founder = T::Lookup::lookup(founder)?;
 			ensure!(!Head::<T, I>::exists(), Error::<T, I>::AlreadyFounded);
 			ensure!(max_members > 1, Error::<T, I>::MaxMembers);
 			// This should never fail in the context of this function...
@@ -1177,15 +1182,22 @@ pub mod pallet {
 			who: AccountIdLookupOf<T>,
 			forgive: bool,
 		) -> DispatchResultWithPostInfo {
-			ensure!(Some(ensure_signed(origin)?) == Founder::<T, I>::get(), Error::<T, I>::NotFounder);
+			ensure!(
+				Some(ensure_signed(origin)?) == Founder::<T, I>::get(),
+				Error::<T, I>::NotFounder
+			);
+			let who = T::Lookup::lookup(who)?;
 			let record = SuspendedMembers::<T, I>::get(&who).ok_or(Error::<T, I>::NotSuspended)?;
 			if forgive {
 				// Try to add member back to society. Can fail with `MaxMembers` limit.
 				Self::reinstate_member(&who, record.rank)?;
 			} else {
 				let payout_record = Payouts::<T, I>::take(&who);
-				let total = payout_record.payouts.into_iter()
-					.map(|x| x.1).fold(Zero::zero(), |acc: BalanceOf<T, I>, x| acc.saturating_add(x));
+				let total = payout_record
+					.payouts
+					.into_iter()
+					.map(|x| x.1)
+					.fold(Zero::zero(), |acc: BalanceOf<T, I>, x| acc.saturating_add(x));
 				Self::unreserve_payout(total);
 			}
 			SuspendedMembers::<T, I>::remove(&who);
@@ -1199,8 +1211,8 @@ pub mod pallet {
 		/// The dispatch origin for this call must be Signed by the Founder.
 		///
 		/// Parameters:
-		/// - `max_members` - The maximum number of members for the society. This must be no
-		///   less than the current number of members.
+		/// - `max_members` - The maximum number of members for the society. This must be no less
+		///   than the current number of members.
 		/// - `max_intake` - The maximum number of candidates per intake period.
 		/// - `max_strikes`: The maximum number of strikes a member may get before they become
 		///   suspended and may only be reinstated by the founder.
@@ -1215,7 +1227,10 @@ pub mod pallet {
 			max_strikes: u32,
 			candidate_deposit: BalanceOf<T, I>,
 		) -> DispatchResult {
-			ensure!(Some(ensure_signed(origin)?) == Founder::<T, I>::get(), Error::<T, I>::NotFounder);
+			ensure!(
+				Some(ensure_signed(origin)?) == Founder::<T, I>::get(),
+				Error::<T, I>::NotFounder
+			);
 			ensure!(max_members >= MemberCount::<T, I>::get(), Error::<T, I>::MaxMembers);
 			let params = GroupParams { max_members, max_intake, max_strikes, candidate_deposit };
 			Parameters::<T, I>::put(&params);
@@ -1228,7 +1243,8 @@ pub mod pallet {
 		#[pallet::weight(T::WeightInfo::punish_skeptic())]
 		pub fn punish_skeptic(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
 			let candidate = ensure_signed(origin)?;
-			let mut candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			let mut candidacy =
+				Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
 			ensure!(!candidacy.skeptic_struck, Error::<T, I>::AlreadyPunished);
 			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
 			let punished = Self::check_skeptic(&candidate, &mut candidacy);
@@ -1241,7 +1257,8 @@ pub mod pallet {
 		#[pallet::weight(T::WeightInfo::claim_membership())]
 		pub fn claim_membership(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
 			let candidate = ensure_signed(origin)?;
-			let candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			let candidacy =
+				Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
 			ensure!(candidacy.tally.clear_approval(), Error::<T, I>::NotApproved);
 			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
 			Self::induct_member(candidate, candidacy, 0)?;
@@ -1252,9 +1269,16 @@ pub mod pallet {
 		/// Founder, only after the period for voting has ended and only when the candidate is not
 		/// clearly rejected.
 		#[pallet::weight(T::WeightInfo::bestow_membership())]
-		pub fn bestow_membership(origin: OriginFor<T>, candidate: T::AccountId) -> DispatchResultWithPostInfo {
-			ensure!(Some(ensure_signed(origin)?) == Founder::<T, I>::get(), Error::<T, I>::NotFounder);
-			let candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+		pub fn bestow_membership(
+			origin: OriginFor<T>,
+			candidate: T::AccountId,
+		) -> DispatchResultWithPostInfo {
+			ensure!(
+				Some(ensure_signed(origin)?) == Founder::<T, I>::get(),
+				Error::<T, I>::NotFounder
+			);
+			let candidacy =
+				Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
 			ensure!(!candidacy.tally.clear_rejection(), Error::<T, I>::Rejected);
 			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
 			Self::induct_member(candidate, candidacy, 0)?;
@@ -1267,9 +1291,16 @@ pub mod pallet {
 		///
 		/// Any bid deposit is lost and voucher is banned.
 		#[pallet::weight(T::WeightInfo::kick_candidate())]
-		pub fn kick_candidate(origin: OriginFor<T>, candidate: T::AccountId) -> DispatchResultWithPostInfo {
-			ensure!(Some(ensure_signed(origin)?) == Founder::<T, I>::get(), Error::<T, I>::NotFounder);
-			let mut candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+		pub fn kick_candidate(
+			origin: OriginFor<T>,
+			candidate: T::AccountId,
+		) -> DispatchResultWithPostInfo {
+			ensure!(
+				Some(ensure_signed(origin)?) == Founder::<T, I>::get(),
+				Error::<T, I>::NotFounder
+			);
+			let mut candidacy =
+				Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
 			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
 			ensure!(!candidacy.tally.clear_approval(), Error::<T, I>::Approved);
 			Self::check_skeptic(&candidate, &mut candidacy);
@@ -1284,7 +1315,8 @@ pub mod pallet {
 		#[pallet::weight(T::WeightInfo::resign_candidacy())]
 		pub fn resign_candidacy(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
 			let candidate = ensure_signed(origin)?;
-			let mut candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			let mut candidacy =
+				Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
 			if !Self::in_progress(candidacy.round) {
 				Self::check_skeptic(&candidate, &mut candidacy);
 			}
@@ -1299,9 +1331,13 @@ pub mod pallet {
 		///
 		/// The bid deposit is lost and the voucher is banned.
 		#[pallet::weight(T::WeightInfo::drop_candidate())]
-		pub fn drop_candidate(origin: OriginFor<T>, candidate: T::AccountId) -> DispatchResultWithPostInfo {
+		pub fn drop_candidate(
+			origin: OriginFor<T>,
+			candidate: T::AccountId,
+		) -> DispatchResultWithPostInfo {
 			ensure_signed(origin)?;
-			let candidacy = Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			let candidacy =
+				Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
 			ensure!(candidacy.tally.clear_rejection(), Error::<T, I>::NotRejected);
 			ensure!(RoundCount::<T, I>::get() > candidacy.round + 1, Error::<T, I>::TooEarly);
 			Self::reject_candidate(&candidate, &candidacy.kind);
@@ -1313,11 +1349,16 @@ pub mod pallet {
 		///
 		/// May be called by any Signed origin, but only after the candidate's candidacy is ended.
 		#[pallet::weight(T::WeightInfo::cleanup_candidacy())]
-		pub fn cleanup_candidacy(origin: OriginFor<T>, candidate: T::AccountId, max: u32) -> DispatchResultWithPostInfo {
+		pub fn cleanup_candidacy(
+			origin: OriginFor<T>,
+			candidate: T::AccountId,
+			max: u32,
+		) -> DispatchResultWithPostInfo {
 			ensure_signed(origin)?;
 			ensure!(!Candidates::<T, I>::contains_key(&candidate), Error::<T, I>::InProgress);
 			let maybe_cursor = VoteClearCursor::<T, I>::get(&candidate);
-			let r = Votes::<T, I>::clear_prefix(&candidate, max, maybe_cursor.as_ref().map(|x| &x[..]));
+			let r =
+				Votes::<T, I>::clear_prefix(&candidate, max, maybe_cursor.as_ref().map(|x| &x[..]));
 			if let Some(cursor) = r.maybe_cursor {
 				VoteClearCursor::<T, I>::insert(&candidate, BoundedVec::truncate_from(cursor));
 			}
@@ -1334,7 +1375,10 @@ pub mod pallet {
 			max: u32,
 		) -> DispatchResultWithPostInfo {
 			ensure_signed(origin)?;
-			ensure!(challenge_round < ChallengeRoundCount::<T, I>::get(), Error::<T, I>::InProgress);
+			ensure!(
+				challenge_round < ChallengeRoundCount::<T, I>::get(),
+				Error::<T, I>::InProgress
+			);
 			let _ = DefenderVotes::<T, I>::clear_prefix(challenge_round, max, None);
 			// clear_prefix() v2 is always returning backend = 0, ignoring it till v3.
 			// let (_, backend, _, _) = r.deconstruct();
@@ -1346,7 +1390,7 @@ pub mod pallet {
 
 /// Simple ensure origin struct to filter for the founder account.
 pub struct EnsureFounder<T>(sp_std::marker::PhantomData<T>);
-impl<T: Config> EnsureOrigin<<T as frame_system::Config>::Origin> for EnsureFounder<T> {
+impl<T: Config> EnsureOrigin<<T as frame_system::Config>::RuntimeOrigin> for EnsureFounder<T> {
 	type Success = T::AccountId;
 	fn try_origin(o: T::RuntimeOrigin) -> Result<Self::Success, T::RuntimeOrigin> {
 		o.into().and_then(|o| match (o, Founder::<T>::get()) {
@@ -1397,7 +1441,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	/// Returns true if the given `target_round` is still in its initial voting phase.
 	fn in_progress(target_round: RoundIndex) -> bool {
 		let round = RoundCount::<T, I>::get();
-		target_round == round && matches!(Self::period(), Period::Voting {..})
+		target_round == round && matches!(Self::period(), Period::Voting { .. })
 	}
 
 	/// Returns the new vote.
@@ -1417,18 +1461,25 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	}
 
 	/// Returns `true` if a punishment was given.
-	fn check_skeptic(candidate: &T::AccountId, candidacy: &mut Candidacy<T::AccountId, BalanceOf<T, I>>) -> bool {
-		if RoundCount::<T, I>::get() != candidacy.round || candidacy.skeptic_struck { return false }
+	fn check_skeptic(
+		candidate: &T::AccountId,
+		candidacy: &mut Candidacy<T::AccountId, BalanceOf<T, I>>,
+	) -> bool {
+		if RoundCount::<T, I>::get() != candidacy.round || candidacy.skeptic_struck {
+			return false
+		}
 		// We expect the skeptic to have voted.
-		let skeptic = match Skeptic::<T, I>::get() { Some(s) => s, None => return false };
+		let skeptic = match Skeptic::<T, I>::get() {
+			Some(s) => s,
+			None => return false,
+		};
 		let maybe_vote = Votes::<T, I>::get(&candidate, &skeptic);
 		let approved = candidacy.tally.clear_approval();
 		let rejected = candidacy.tally.clear_rejection();
 		match (maybe_vote, approved, rejected) {
-			(None, _, _)
-			| (Some(Vote { approve: true, .. }), false, true)
-			| (Some(Vote { approve: false, .. }), true, false)
-			=> {
+			(None, _, _) |
+			(Some(Vote { approve: true, .. }), false, true) |
+			(Some(Vote { approve: false, .. }), true, false) => {
 				// Can't do much if the punishment doesn't work out.
 				if Self::strike_member(&skeptic).is_ok() {
 					candidacy.skeptic_struck = true;
@@ -1458,10 +1509,9 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 			// Check defender skeptic voted and that their vote was with the majority.
 			let skeptic_vote = DefenderVotes::<T, I>::get(round, &skeptic);
 			match (skeptic_vote, tally.more_approvals(), tally.more_rejections()) {
-				(None, _, _)
-				| (Some(Vote { approve: true, .. }), false, true)
-				| (Some(Vote { approve: false, .. }), true, false)
-				=> {
+				(None, _, _) |
+				(Some(Vote { approve: true, .. }), false, true) |
+				(Some(Vote { approve: false, .. }), true, false) => {
 					// Punish skeptic and challenge them next.
 					let _ = Self::strike_member(&skeptic);
 					let founder = Founder::<T, I>::get();
@@ -1469,8 +1519,8 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 					if Some(&skeptic) != founder.as_ref() && Some(&skeptic) != head.as_ref() {
 						next_defender = Some(skeptic);
 					}
-				}
-				_ => {}
+				},
+				_ => {},
 			}
 			round.saturating_inc();
 			ChallengeRoundCount::<T, I>::put(round);
@@ -1479,8 +1529,11 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		// Avoid challenging if there's only two members since we never challenge the Head or
 		// the Founder.
 		if MemberCount::<T, I>::get() > 2 {
-			let defender = next_defender.or_else(|| Self::pick_defendent(rng)).expect("exited if members empty; qed");
-			let skeptic = Self::pick_member_except(rng, &defender).expect("exited if members empty; qed");
+			let defender = next_defender
+				.or_else(|| Self::pick_defendent(rng))
+				.expect("exited if members empty; qed");
+			let skeptic =
+				Self::pick_member_except(rng, &defender).expect("exited if members empty; qed");
 			Self::deposit_event(Event::<T, I>::Challenged { member: defender.clone() });
 			Defending::<T, I>::put((defender, skeptic, Tally::default()));
 		} else {
@@ -1542,7 +1595,8 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 			Some(params) => params,
 			None => return 0,
 		};
-		let max_selections: u32 = params.max_intake
+		let max_selections: u32 = params
+			.max_intake
 			.min(params.max_members.saturating_sub(member_count))
 			.min(bids.len() as u32);
 
@@ -1553,9 +1607,9 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		bids.retain(|bid| {
 			// We only accept a zero bid as the first selection.
 			total_cost.saturating_accrue(bid.value);
-			let accept = selections < max_selections
-				&& (!bid.value.is_zero() || selections == 0)
-				&& total_cost <= pot;
+			let accept = selections < max_selections &&
+				(!bid.value.is_zero() || selections == 0) &&
+				total_cost <= pot;
 			if accept {
 				let candidacy = Candidacy {
 					round,
@@ -1585,7 +1639,10 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	) {
 		let pos = bids.iter().position(|bid| bid.value > value).unwrap_or(bids.len());
 		let r = bids.force_insert_keep_left(pos, Bid { value, who: who.clone(), kind: bid_kind });
-		let maybe_discarded = match r { Ok(x) => x, Err(x) => Some(x) };
+		let maybe_discarded = match r {
+			Ok(x) => x,
+			Err(x) => Some(x),
+		};
 		if let Some(discarded) = maybe_discarded {
 			Self::clean_bid(&discarded);
 			Self::deposit_event(Event::<T, I>::AutoUnbid { candidate: discarded.who });
@@ -1626,7 +1683,9 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 				debug_assert!(T::Currency::repatriate_reserved(&who, &pot, *deposit, free).is_ok());
 			},
 			BidKind::Vouch(voucher, _) => {
-				Members::<T, I>::mutate_extant(voucher, |record| record.vouching = Some(VouchingStatus::Banned));
+				Members::<T, I>::mutate_extant(voucher, |record| {
+					record.vouching = Some(VouchingStatus::Banned)
+				});
 			},
 		}
 	}
@@ -1649,7 +1708,10 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	fn insert_member(who: &T::AccountId, rank: Rank) -> DispatchResult {
 		let params = Parameters::<T, I>::get().ok_or(Error::<T, I>::NotGroup)?;
 		ensure!(MemberCount::<T, I>::get() < params.max_members, Error::<T, I>::MaxMembers);
-		let index = MemberCount::<T, I>::mutate(|i| { i.saturating_accrue(1); *i - 1 });
+		let index = MemberCount::<T, I>::mutate(|i| {
+			i.saturating_accrue(1);
+			*i - 1
+		});
 		let record = MemberRecord { rank, strikes: 0, vouching: None, index };
 		Members::<T, I>::insert(who, record);
 		MemberByIndex::<T, I>::insert(index, who);
@@ -1683,11 +1745,14 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 
 		let next_head = NextHead::<T, I>::get()
 			.filter(|old| {
-				old.round > candidacy.round
-				|| old.round == candidacy.round && old.bid < candidacy.bid
-			}).unwrap_or_else(||
-				IntakeRecord { who: candidate.clone(), bid: candidacy.bid, round: candidacy.round }
-			);
+				old.round > candidacy.round ||
+					old.round == candidacy.round && old.bid < candidacy.bid
+			})
+			.unwrap_or_else(|| IntakeRecord {
+				who: candidate.clone(),
+				bid: candidacy.bid,
+				round: candidacy.round,
+			});
 		NextHead::<T, I>::put(next_head);
 
 		let now = <frame_system::Pallet<T>>::block_number();
@@ -1707,7 +1772,9 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 
 		if record.strikes >= T::GraceStrikes::get() {
 			// Too many strikes: slash the payout in half.
-			let total_payout = Payouts::<T, I>::get(who).payouts.iter()
+			let total_payout = Payouts::<T, I>::get(who)
+				.payouts
+				.iter()
 				.fold(BalanceOf::<T, I>::zero(), |acc, x| acc.saturating_add(x.1));
 			Self::slash_payout(who, total_payout / 2u32.into());
 		}
@@ -1735,14 +1802,20 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		ensure!(Founder::<T, I>::get().as_ref() != Some(m), Error::<T, I>::Founder);
 		if let Some(mut record) = Members::<T, I>::get(m) {
 			let index = record.index;
-			let last_index = MemberCount::<T, I>::mutate(|i| { i.saturating_reduce(1); *i });
+			let last_index = MemberCount::<T, I>::mutate(|i| {
+				i.saturating_reduce(1);
+				*i
+			});
 			if index != last_index {
-				// Move the member with the last index down to the index of the member to be removed.
+				// Move the member with the last index down to the index of the member to be
+				// removed.
 				if let Some(other) = MemberByIndex::<T, I>::get(last_index) {
 					MemberByIndex::<T, I>::insert(index, &other);
-					Members::<T, I>::mutate(other, |m_r|
-						if let Some(r) = m_r { r.index = index }
-					);
+					Members::<T, I>::mutate(other, |m_r| {
+						if let Some(r) = m_r {
+							r.index = index
+						}
+					});
 				} else {
 					debug_assert!(false, "ERROR: No member at the last index position?");
 				}
@@ -1795,8 +1868,12 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 
 	/// Select a member at random except `exception`, given the RNG `rng`.
 	///
-	/// If `exception` is the only member (or the state is inconsistent), then `None` may be returned.
-	fn pick_member_except(rng: &mut impl RngCore, exception: &T::AccountId) -> Option<T::AccountId> {
+	/// If `exception` is the only member (or the state is inconsistent), then `None` may be
+	/// returned.
+	fn pick_member_except(
+		rng: &mut impl RngCore,
+		exception: &T::AccountId,
+	) -> Option<T::AccountId> {
 		let member_count = MemberCount::<T, I>::get();
 		if member_count <= 1 {
 			return None
@@ -1878,7 +1955,9 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	/// It is the caller's duty to ensure that `who` is already a member. This does nothing if `who`
 	/// is not a member or if `value` is zero.
 	fn bump_payout(who: &T::AccountId, when: T::BlockNumber, value: BalanceOf<T, I>) {
-		if value.is_zero() { return }
+		if value.is_zero() {
+			return
+		}
 		if let Some(MemberRecord { rank: 0, .. }) = Members::<T, I>::get(who) {
 			Payouts::<T, I>::mutate(who, |record| {
 				// Members of rank 1 never get payouts.
@@ -1922,12 +2001,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 
 		// this should never fail since we ensure we can afford the payouts in a previous
 		// block, but there's not much we can do to recover if it fails anyway.
-		let res = T::Currency::transfer(
-			&Self::account_id(),
-			&Self::payouts(),
-			amount,
-			AllowDeath,
-		);
+		let res = T::Currency::transfer(&Self::account_id(), &Self::payouts(), amount, AllowDeath);
 		debug_assert!(res.is_ok());
 	}
 
@@ -1939,12 +2013,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 
 		// this should never fail since we ensure we can afford the payouts in a previous
 		// block, but there's not much we can do to recover if it fails anyway.
-		let res = T::Currency::transfer(
-			&Self::payouts(),
-			&Self::account_id(),
-			amount,
-			AllowDeath,
-		);
+		let res = T::Currency::transfer(&Self::payouts(), &Self::account_id(), amount, AllowDeath);
 		debug_assert!(res.is_ok());
 	}
 
diff --git a/frame/society/src/migrations.rs b/frame/society/src/migrations.rs
index 29d4bea461a9b..8691e4d59b317 100644
--- a/frame/society/src/migrations.rs
+++ b/frame/society/src/migrations.rs
@@ -35,64 +35,74 @@ pub(crate) mod old {
 		Approve,
 	}
 
-	#[storage_alias] pub type Bids<T: Config<I>, I: 'static> = StorageValue<
+	#[storage_alias]
+	pub type Bids<T: Config<I>, I: 'static> = StorageValue<
 		Pallet<T, I>,
 		Vec<Bid<<T as frame_system::Config>::AccountId, BalanceOf<T, I>>>,
 		ValueQuery,
 	>;
-	#[storage_alias] pub type Candidates<T: Config<I>, I: 'static> = StorageValue<
+	#[storage_alias]
+	pub type Candidates<T: Config<I>, I: 'static> = StorageValue<
 		Pallet<T, I>,
 		Vec<Bid<<T as frame_system::Config>::AccountId, BalanceOf<T, I>>>,
 		ValueQuery,
 	>;
-	#[storage_alias] pub type Votes<T: Config<I>, I: 'static> = StorageDoubleMap<
+	#[storage_alias]
+	pub type Votes<T: Config<I>, I: 'static> = StorageDoubleMap<
 		Pallet<T, I>,
-		Twox64Concat, <T as frame_system::Config>::AccountId,
-		Twox64Concat, <T as frame_system::Config>::AccountId,
+		Twox64Concat,
+		<T as frame_system::Config>::AccountId,
+		Twox64Concat,
+		<T as frame_system::Config>::AccountId,
 		Vote,
 	>;
-	#[storage_alias] pub type SuspendedCandidates<T: Config<I>, I: 'static> = StorageMap<
+	#[storage_alias]
+	pub type SuspendedCandidates<T: Config<I>, I: 'static> = StorageMap<
 		Pallet<T, I>,
-		Twox64Concat, <T as frame_system::Config>::AccountId,
+		Twox64Concat,
+		<T as frame_system::Config>::AccountId,
 		(BalanceOf<T, I>, BidKind<<T as frame_system::Config>::AccountId, BalanceOf<T, I>>),
 	>;
-	#[storage_alias] pub type Members<T: Config<I>, I: 'static> = StorageValue<
-		Pallet<T, I>,
-		Vec<<T as frame_system::Config>::AccountId>,
-		ValueQuery,
-	>;
-	#[storage_alias] pub type Vouching<T: Config<I>, I: 'static> = StorageMap<
+	#[storage_alias]
+	pub type Members<T: Config<I>, I: 'static> =
+		StorageValue<Pallet<T, I>, Vec<<T as frame_system::Config>::AccountId>, ValueQuery>;
+	#[storage_alias]
+	pub type Vouching<T: Config<I>, I: 'static> = StorageMap<
 		Pallet<T, I>,
-		Twox64Concat, <T as frame_system::Config>::AccountId,
+		Twox64Concat,
+		<T as frame_system::Config>::AccountId,
 		VouchingStatus,
 	>;
-	#[storage_alias] pub type Strikes<T: Config<I>, I: 'static> = StorageMap<
+	#[storage_alias]
+	pub type Strikes<T: Config<I>, I: 'static> = StorageMap<
 		Pallet<T, I>,
-		Twox64Concat, <T as frame_system::Config>::AccountId,
+		Twox64Concat,
+		<T as frame_system::Config>::AccountId,
 		StrikeCount,
 		ValueQuery,
 	>;
-	#[storage_alias] pub type Payouts<T: Config<I>, I: 'static> = StorageMap<
+	#[storage_alias]
+	pub type Payouts<T: Config<I>, I: 'static> = StorageMap<
 		Pallet<T, I>,
-		Twox64Concat, <T as frame_system::Config>::AccountId,
+		Twox64Concat,
+		<T as frame_system::Config>::AccountId,
 		Vec<(<T as frame_system::Config>::BlockNumber, BalanceOf<T, I>)>,
 		ValueQuery,
 	>;
-	#[storage_alias] pub type SuspendedMembers<T: Config<I>, I: 'static> = StorageMap<
+	#[storage_alias]
+	pub type SuspendedMembers<T: Config<I>, I: 'static> = StorageMap<
 		Pallet<T, I>,
-		Twox64Concat, <T as frame_system::Config>::AccountId,
+		Twox64Concat,
+		<T as frame_system::Config>::AccountId,
 		bool,
 		ValueQuery,
 	>;
-	#[storage_alias] pub type Defender<T: Config<I>, I: 'static> = StorageValue<
-		Pallet<T, I>,
-		<T as frame_system::Config>::AccountId,
-	>;
-	#[storage_alias] pub type DefenderVotes<T: Config<I>, I: 'static> = StorageMap<
-		Pallet<T, I>,
-		Twox64Concat, <T as frame_system::Config>::AccountId,
-		Vote,
-	>;
+	#[storage_alias]
+	pub type Defender<T: Config<I>, I: 'static> =
+		StorageValue<Pallet<T, I>, <T as frame_system::Config>::AccountId>;
+	#[storage_alias]
+	pub type DefenderVotes<T: Config<I>, I: 'static> =
+		StorageMap<Pallet<T, I>, Twox64Concat, <T as frame_system::Config>::AccountId, Vote>;
 }
 
 pub fn can_migrate<T: Config<I>, I: Instance + 'static>() -> bool {
@@ -148,11 +158,8 @@ pub fn assert_internal_consistency<T: Config<I>, I: Instance + 'static>() {
 	assert!(!old::Members::<T, I>::exists());
 }
 
-pub fn from_original<
-	T: Config<I>,
-	I: Instance + 'static,
->(
-	past_payouts: &mut [(<T as frame_system::Config>::AccountId, BalanceOf<T, I>)]
+pub fn from_original<T: Config<I>, I: Instance + 'static>(
+	past_payouts: &mut [(<T as frame_system::Config>::AccountId, BalanceOf<T, I>)],
 ) {
 	// First check that this is the original state layout. This is easy since the original layout
 	// contained the Members value, and this value no longer exists in the new layout.
@@ -173,23 +180,21 @@ pub fn from_original<
 		// Migrate Votes from old::Votes
 		// No need to drain, since we're overwriting values.
 		for (voter, vote) in old::Votes::<T, I>::iter_prefix(&candidate) {
-			Votes::<T, I>::insert(&candidate, &voter, Vote {
-				approve: vote == old::Vote::Approve,
-				weight: 1,
-			});
+			Votes::<T, I>::insert(
+				&candidate,
+				&voter,
+				Vote { approve: vote == old::Vote::Approve, weight: 1 },
+			);
 			match vote {
 				old::Vote::Approve => tally.approvals.saturating_inc(),
 				old::Vote::Reject => tally.rejections.saturating_inc(),
 				old::Vote::Skeptic => Skeptic::<T, I>::put(&voter),
 			}
 		}
-		Candidates::<T, I>::insert(&candidate, Candidacy {
-			round: 0,
-			kind,
-			tally,
-			skeptic_struck: false,
-			bid: value,
-		});
+		Candidates::<T, I>::insert(
+			&candidate,
+			Candidacy { round: 0, kind, tally, skeptic_struck: false, bid: value },
+		);
 	}
 
 	// Migrate Members from old::Members old::Strikes old::Vouching
@@ -204,7 +209,8 @@ pub fn from_original<
 	}
 	MemberCount::<T, I>::put(member_count);
 
-	// Migrate Payouts from: old::Payouts and raw info (needed since we can't query old chain state).
+	// Migrate Payouts from: old::Payouts and raw info (needed since we can't query old chain
+	// state).
 	past_payouts.sort();
 	for (who, mut payouts) in old::Payouts::<T, I>::iter() {
 		payouts.truncate(T::MaxPayouts::get() as usize);
@@ -236,17 +242,12 @@ pub fn from_original<
 	let _ = old::DefenderVotes::<T, I>::clear(u32::MAX, None);
 }
 
-pub fn from_raw_past_payouts<
-	T: Config<I>,
-	I: Instance + 'static,
->(
-	past_payouts_raw: &[(&[u8], u128)]
+pub fn from_raw_past_payouts<T: Config<I>, I: Instance + 'static>(
+	past_payouts_raw: &[(&[u8], u128)],
 ) -> Vec<(<T as frame_system::Config>::AccountId, BalanceOf<T, I>)> {
-	past_payouts_raw.iter()
-		.filter_map(|(x, y)| Some((
-			Decode::decode(&mut x.as_ref()).ok()?,
-			(*y).try_into().ok()?,
-		)))
+	past_payouts_raw
+		.iter()
+		.filter_map(|(x, y)| Some((Decode::decode(&mut x.as_ref()).ok()?, (*y).try_into().ok()?)))
 		.collect()
 }
 
diff --git a/frame/society/src/mock.rs b/frame/society/src/mock.rs
index 63e939ef1df6e..e53477754a072 100644
--- a/frame/society/src/mock.rs
+++ b/frame/society/src/mock.rs
@@ -32,6 +32,8 @@ use sp_runtime::{
 	traits::{BlakeTwo256, IdentityLookup},
 };
 
+use RuntimeOrigin as Origin;
+
 type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;
 type Block = frame_system::mocking::MockBlock<Test>;
 
@@ -102,7 +104,7 @@ impl pallet_balances::Config for Test {
 }
 
 impl Config for Test {
-	type Event = Event;
+	type RuntimeEvent = RuntimeEvent;
 	type PalletId = SocietyPalletId;
 	type Currency = pallet_balances::Pallet<Self>;
 	type Randomness = TestRandomness<Self>;
@@ -151,9 +153,7 @@ impl EnvBuilder {
 		pallet_balances::GenesisConfig::<Test> { balances: self.balances }
 			.assimilate_storage(&mut t)
 			.unwrap();
-		pallet_society::GenesisConfig::<Test> {
-			pot: self.pot,
-		}
+		pallet_society::GenesisConfig::<Test> { pot: self.pot }
 			.assimilate_storage(&mut t)
 			.unwrap();
 		let mut ext: sp_io::TestExternalities = t.into();
@@ -223,11 +223,17 @@ pub fn conclude_intake(allow_resignation: bool, judge_intake: Option<bool>) {
 	for (who, candidacy) in Candidates::<Test>::iter() {
 		if candidacy.tally.clear_approval() {
 			assert_ok!(Society::claim_membership(Origin::signed(who)));
-			assert_noop!(Society::claim_membership(Origin::signed(who)), Error::<Test>::NotCandidate);
+			assert_noop!(
+				Society::claim_membership(Origin::signed(who)),
+				Error::<Test>::NotCandidate
+			);
 			continue
 		}
 		if candidacy.tally.clear_rejection() && allow_resignation {
-			assert_noop!(Society::claim_membership(Origin::signed(who)), Error::<Test>::NotApproved);
+			assert_noop!(
+				Society::claim_membership(Origin::signed(who)),
+				Error::<Test>::NotApproved
+			);
 			assert_ok!(Society::resign_candidacy(Origin::signed(who)));
 			continue
 		}
@@ -244,9 +250,15 @@ pub fn conclude_intake(allow_resignation: bool, judge_intake: Option<bool>) {
 			}
 		}
 		if candidacy.tally.clear_rejection() && round > candidacy.round + 1 {
-			assert_noop!(Society::claim_membership(Origin::signed(who)), Error::<Test>::NotApproved);
+			assert_noop!(
+				Society::claim_membership(Origin::signed(who)),
+				Error::<Test>::NotApproved
+			);
 			assert_ok!(Society::drop_candidate(Origin::signed(0), who));
-			assert_noop!(Society::drop_candidate(Origin::signed(0), who), Error::<Test>::NotCandidate);
+			assert_noop!(
+				Society::drop_candidate(Origin::signed(0), who),
+				Error::<Test>::NotCandidate
+			);
 			continue
 		}
 		if !candidacy.skeptic_struck {
diff --git a/frame/society/src/tests.rs b/frame/society/src/tests.rs
index ac60750c0d7e2..28e9ea028c333 100644
--- a/frame/society/src/tests.rs
+++ b/frame/society/src/tests.rs
@@ -18,14 +18,16 @@
 //! Tests for the module.
 
 use super::*;
-use mock::*;
 use migrations::old;
+use mock::*;
 
 use frame_support::{assert_noop, assert_ok};
 use sp_core::blake2_256;
 use sp_runtime::traits::BadOrigin;
-use VouchingStatus::*;
 use BidKind::*;
+use VouchingStatus::*;
+
+use RuntimeOrigin as Origin;
 
 #[test]
 fn migration_works() {
@@ -42,7 +44,12 @@ fn migration_works() {
 		old::Strikes::<Test, ()>::insert(30, 2);
 		old::Strikes::<Test, ()>::insert(40, 5);
 		old::Payouts::<Test, ()>::insert(20, vec![(1, 1)]);
-		old::Payouts::<Test, ()>::insert(30, (0..=<Test as Config>::MaxPayouts::get()).map(|i| (i as u64, i as u64)).collect::<Vec<_>>());
+		old::Payouts::<Test, ()>::insert(
+			30,
+			(0..=<Test as Config>::MaxPayouts::get())
+				.map(|i| (i as u64, i as u64))
+				.collect::<Vec<_>>(),
+		);
 		old::SuspendedMembers::<Test, ()>::insert(40, true);
 
 		old::Defender::<Test, ()>::put(20);
@@ -70,14 +77,17 @@ fn migration_works() {
 			.collect::<Vec<_>>();
 		old::Bids::<Test, ()>::put(bids);
 
-		migrations::from_original::<Test, ()>(&mut[][..]);
+		migrations::from_original::<Test, ()>(&mut [][..]);
 		migrations::assert_internal_consistency::<Test, ()>();
 
-		assert_eq!(membership(), vec![
-			(10, MemberRecord { rank: 0, strikes: 0, vouching: None, index: 0 }),
-			(20, MemberRecord { rank: 0, strikes: 1, vouching: None, index: 1 }),
-			(30, MemberRecord { rank: 0, strikes: 2, vouching: Some(Vouching), index: 2 }),
-		]);
+		assert_eq!(
+			membership(),
+			vec![
+				(10, MemberRecord { rank: 0, strikes: 0, vouching: None, index: 0 }),
+				(20, MemberRecord { rank: 0, strikes: 1, vouching: None, index: 1 }),
+				(30, MemberRecord { rank: 0, strikes: 2, vouching: Some(Vouching), index: 2 }),
+			]
+		);
 		assert_eq!(Payouts::<Test>::get(10), PayoutRecord::default());
 		let payouts = vec![(1, 1)].try_into().unwrap();
 		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts });
@@ -87,9 +97,10 @@ fn migration_works() {
 			.try_into()
 			.unwrap();
 		assert_eq!(Payouts::<Test>::get(30), PayoutRecord { paid: 0, payouts });
-		assert_eq!(SuspendedMembers::<Test>::iter().collect::<Vec<_>>(), vec![
-			(40, MemberRecord { rank: 0, strikes: 5, vouching: Some(Banned), index: 0 }),
-		]);
+		assert_eq!(
+			SuspendedMembers::<Test>::iter().collect::<Vec<_>>(),
+			vec![(40, MemberRecord { rank: 0, strikes: 5, vouching: Some(Banned), index: 0 }),]
+		);
 		let bids: BoundedVec<_, <Test as Config>::MaxBids> = (0..<Test as Config>::MaxBids::get())
 			.map(|i| Bid {
 				who: 100u128 + i as u128,
@@ -101,26 +112,35 @@ fn migration_works() {
 			.unwrap();
 		assert_eq!(Bids::<Test>::get(), bids);
 		assert_eq!(RoundCount::<Test, ()>::get(), 0);
-		assert_eq!(candidacies(), vec![
-			(60, Candidacy {
-				round: 0,
-				kind: Deposit(100),
-				bid: 200,
-				tally: Tally { approvals: 1, rejections: 0 },
-				skeptic_struck: false,
-			}),
-			(70, Candidacy {
-				round: 0,
-				kind: Vouch(30, 30),
-				bid: 100,
-				tally: Tally { approvals: 2, rejections: 1 },
-				skeptic_struck: false,
-			}),
-		]);
-		assert_eq!(Votes::<Test>::get(60, 10), Some(Vote { approve: true, weight: 1}));
-		assert_eq!(Votes::<Test>::get(70, 10), Some(Vote { approve: false, weight: 1}));
-		assert_eq!(Votes::<Test>::get(70, 20), Some(Vote { approve: true, weight: 1}));
-		assert_eq!(Votes::<Test>::get(70, 30), Some(Vote { approve: true, weight: 1}));
+		assert_eq!(
+			candidacies(),
+			vec![
+				(
+					60,
+					Candidacy {
+						round: 0,
+						kind: Deposit(100),
+						bid: 200,
+						tally: Tally { approvals: 1, rejections: 0 },
+						skeptic_struck: false,
+					}
+				),
+				(
+					70,
+					Candidacy {
+						round: 0,
+						kind: Vouch(30, 30),
+						bid: 100,
+						tally: Tally { approvals: 2, rejections: 1 },
+						skeptic_struck: false,
+					}
+				),
+			]
+		);
+		assert_eq!(Votes::<Test>::get(60, 10), Some(Vote { approve: true, weight: 1 }));
+		assert_eq!(Votes::<Test>::get(70, 10), Some(Vote { approve: false, weight: 1 }));
+		assert_eq!(Votes::<Test>::get(70, 20), Some(Vote { approve: true, weight: 1 }));
+		assert_eq!(Votes::<Test>::get(70, 30), Some(Vote { approve: true, weight: 1 }));
 	});
 }
 
@@ -133,9 +153,20 @@ fn founding_works() {
 		assert_eq!(Pot::<Test>::get(), 0);
 		// Account 1 is set as the founder origin
 		// Account 5 cannot start a society
-		assert_noop!(Society::found_society(Origin::signed(5), 20, 100, 10, 2, 25, vec![]), BadOrigin);
+		assert_noop!(
+			Society::found_society(Origin::signed(5), 20, 100, 10, 2, 25, vec![]),
+			BadOrigin
+		);
 		// Account 1 can start a society, where 10 is the founding member
-		assert_ok!(Society::found_society(Origin::signed(1), 10, 100, 10, 2, 25, b"be cool".to_vec()));
+		assert_ok!(Society::found_society(
+			Origin::signed(1),
+			10,
+			100,
+			10,
+			2,
+			25,
+			b"be cool".to_vec()
+		));
 		// Society members only include 10
 		assert_eq!(members(), vec![10]);
 		// 10 is the head of the society
@@ -250,7 +281,7 @@ fn bidding_works() {
 		// No more candidates satisfy the requirements
 		assert_eq!(candidacies(), vec![]);
 		assert_ok!(Society::defender_vote(Origin::signed(10), true)); // Keep defender around
-		// Next period
+															  // Next period
 		run_to_block(16);
 		// Same members
 		assert_eq!(members(), vec![10, 30, 40, 50]);
@@ -376,16 +407,25 @@ fn slash_payout_works() {
 		assert_ok!(Society::vote(Origin::signed(10), 20, true));
 		conclude_intake(true, None);
 		// payout in queue
-		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(8, 1000)].try_into().unwrap() });
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![(8, 1000)].try_into().unwrap() }
+		);
 		assert_noop!(Society::payout(Origin::signed(20)), Error::<Test>::NoPayout);
 		// slash payout
 		assert_eq!(Society::slash_payout(&20, 500), 500);
-		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(8, 500)].try_into().unwrap() });
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![(8, 500)].try_into().unwrap() }
+		);
 		run_to_block(8);
 		// payout should be here, but 500 less
 		assert_ok!(Society::payout(RuntimeOrigin::signed(20)));
 		assert_eq!(Balances::free_balance(20), 550);
-		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 500, payouts: Default::default() });
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 500, payouts: Default::default() }
+		);
 	});
 }
 
@@ -400,13 +440,25 @@ fn slash_payout_multi_works() {
 		Society::bump_payout(&20, 15, 100);
 		Society::bump_payout(&20, 20, 100);
 		// payouts in queue
-		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(5, 100), (10, 100), (15, 100), (20, 100)].try_into().unwrap() });
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord {
+				paid: 0,
+				payouts: vec![(5, 100), (10, 100), (15, 100), (20, 100)].try_into().unwrap()
+			}
+		);
 		// slash payout
 		assert_eq!(Society::slash_payout(&20, 250), 250);
-		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(15, 50), (20, 100)].try_into().unwrap() });
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![(15, 50), (20, 100)].try_into().unwrap() }
+		);
 		// slash again
 		assert_eq!(Society::slash_payout(&20, 50), 50);
-		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(20, 100)].try_into().unwrap() });
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![(20, 100)].try_into().unwrap() }
+		);
 	});
 }
 
@@ -425,7 +477,6 @@ fn suspended_member_life_cycle_works() {
 		next_intake();
 		conclude_intake(false, None);
 
-
 		// 2 strikes are accumulated, and 20 is suspended :(
 		assert!(SuspendedMembers::<Test>::contains_key(20));
 		assert_eq!(members(), vec![10]);
@@ -435,7 +486,10 @@ fn suspended_member_life_cycle_works() {
 		assert_noop!(Society::payout(Origin::signed(20)), Error::<Test>::NotMember);
 
 		// Normal people cannot make judgement
-		assert_noop!(Society::judge_suspended_member(Origin::signed(20), 20, true), Error::<Test>::NotFounder);
+		assert_noop!(
+			Society::judge_suspended_member(Origin::signed(20), 20, true),
+			Error::<Test>::NotFounder
+		);
 
 		// Suspension judgment origin can judge thee
 		// Suspension judgement origin forgives the suspended member
@@ -451,7 +505,10 @@ fn suspended_member_life_cycle_works() {
 		// Cleaned up
 		assert!(!SuspendedMembers::<Test>::contains_key(20));
 		assert_eq!(members(), vec![10]);
-		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![].try_into().unwrap() });
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![].try_into().unwrap() }
+		);
 	});
 }
 
@@ -468,12 +525,15 @@ fn suspended_candidate_rejected_works() {
 
 		// Rotation Period
 		next_intake();
-		assert_eq!(candidacies(), vec![
-			(40, candidacy(1, 10, Deposit(25), 0, 0)),
-			(50, candidacy(1, 10, Deposit(25), 0, 0)),
-			(60, candidacy(1, 10, Deposit(25), 0, 0)),
-			(70, candidacy(1, 10, Deposit(25), 0, 0)),
-		]);
+		assert_eq!(
+			candidacies(),
+			vec![
+				(40, candidacy(1, 10, Deposit(25), 0, 0)),
+				(50, candidacy(1, 10, Deposit(25), 0, 0)),
+				(60, candidacy(1, 10, Deposit(25), 0, 0)),
+				(70, candidacy(1, 10, Deposit(25), 0, 0)),
+			]
+		);
 
 		// Split vote over all.
 		for &x in &[40, 50, 60, 70] {
@@ -557,7 +617,10 @@ fn unpaid_vouch_works() {
 		conclude_intake(true, None);
 		assert_eq!(members(), vec![10, 20]);
 		// Vouched user gets whatever remains after the voucher's reservation.
-		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(8, 900)].try_into().unwrap() });
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![(8, 900)].try_into().unwrap() }
+		);
 		// 10 is no longer vouching
 		assert_eq!(Members::<Test>::get(10).unwrap().vouching, None);
 	});
@@ -580,9 +643,15 @@ fn paid_vouch_works() {
 
 		assert_eq!(members(), vec![10, 20, 30]);
 		// Voucher wins a portion of the payment
-		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(8, 100)].try_into().unwrap() });
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![(8, 100)].try_into().unwrap() }
+		);
 		// Vouched user wins the rest
-		assert_eq!(Payouts::<Test>::get(30), PayoutRecord { paid: 0, payouts: vec![(8, 900)].try_into().unwrap() });
+		assert_eq!(
+			Payouts::<Test>::get(30),
+			PayoutRecord { paid: 0, payouts: vec![(8, 900)].try_into().unwrap() }
+		);
 		// 20 is no longer vouching
 		assert_eq!(Members::<Test>::get(20).unwrap().vouching, None);
 	});
@@ -605,9 +674,15 @@ fn voucher_cannot_win_more_than_bid() {
 		conclude_intake(true, None);
 		assert_eq!(members(), vec![10, 20, 30]);
 		// Voucher wins as much as the bid
-		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(8, 100)].try_into().unwrap() });
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![(8, 100)].try_into().unwrap() }
+		);
 		// Vouched user gets nothing
-		assert_eq!(Payouts::<Test>::get(30), PayoutRecord { paid: 0, payouts: vec![].try_into().unwrap() });
+		assert_eq!(
+			Payouts::<Test>::get(30),
+			PayoutRecord { paid: 0, payouts: vec![].try_into().unwrap() }
+		);
 	});
 }
 
@@ -746,12 +821,10 @@ fn founder_and_head_cannot_be_removed() {
 		Skeptic::<Test>::put(50);
 		conclude_intake(false, None);
 		next_intake();
-		assert_eq!(SuspendedMembers::<Test>::get(50), Some(MemberRecord {
-			rank: 0,
-			strikes: 3,
-			vouching: None,
-			index: 1,
-		}));
+		assert_eq!(
+			SuspendedMembers::<Test>::get(50),
+			Some(MemberRecord { rank: 0, strikes: 3, vouching: None, index: 1 })
+		);
 		assert_eq!(members(), vec![10, 80]);
 	});
 }
@@ -813,12 +886,10 @@ fn challenges_work() {
 		next_challenge();
 		// 30 is suspended
 		assert_eq!(members(), vec![10, 20, 40]);
-		assert_eq!(SuspendedMembers::<Test>::get(30), Some(MemberRecord {
-			rank: 0,
-			strikes: 0,
-			vouching: None,
-			index: 2,
-		}));
+		assert_eq!(
+			SuspendedMembers::<Test>::get(30),
+			Some(MemberRecord { rank: 0, strikes: 0, vouching: None, index: 2 })
+		);
 		// Reset votes for last challenge
 		assert_ok!(Society::cleanup_challenge(Origin::signed(0), 2, 10));
 		// New defender is chosen
@@ -843,10 +914,22 @@ fn bad_vote_slash_works() {
 		Society::bump_payout(&40, 5, 100);
 		Society::bump_payout(&50, 5, 100);
 		// Check starting point
-		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() });
-		assert_eq!(Payouts::<Test>::get(30), PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() });
-		assert_eq!(Payouts::<Test>::get(40), PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() });
-		assert_eq!(Payouts::<Test>::get(50), PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() });
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() }
+		);
+		assert_eq!(
+			Payouts::<Test>::get(30),
+			PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() }
+		);
+		assert_eq!(
+			Payouts::<Test>::get(40),
+			PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() }
+		);
+		assert_eq!(
+			Payouts::<Test>::get(50),
+			PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() }
+		);
 		// Create a new bid
 		assert_ok!(Society::bid(Origin::signed(60), 1000));
 		next_intake();
@@ -863,10 +946,22 @@ fn bad_vote_slash_works() {
 		assert_eq!(Members::<Test>::get(40).unwrap().strikes, 0);
 		assert_eq!(Members::<Test>::get(50).unwrap().strikes, 0);
 		// Their payout is slashed, a random person is rewarded
-		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![(5, 50)].try_into().unwrap() });
-		assert_eq!(Payouts::<Test>::get(30), PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() });
-		assert_eq!(Payouts::<Test>::get(40), PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() });
-		assert_eq!(Payouts::<Test>::get(50), PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() });
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![(5, 50)].try_into().unwrap() }
+		);
+		assert_eq!(
+			Payouts::<Test>::get(30),
+			PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() }
+		);
+		assert_eq!(
+			Payouts::<Test>::get(40),
+			PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() }
+		);
+		assert_eq!(
+			Payouts::<Test>::get(50),
+			PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() }
+		);
 	});
 }
 
@@ -881,10 +976,7 @@ fn user_cannot_bid_twice() {
 		assert_noop!(Society::bid(Origin::signed(30), 100), Error::<Test>::AlreadyBid);
 		// Cannot vouch when already bid
 		place_members([50]);
-		assert_noop!(
-			Society::vouch(Origin::signed(50), 20, 100, 100),
-			Error::<Test>::AlreadyBid
-		);
+		assert_noop!(Society::vouch(Origin::signed(50), 20, 100, 100), Error::<Test>::AlreadyBid);
 	});
 }
 
@@ -934,8 +1026,14 @@ fn vouching_handles_removed_member_with_candidate() {
 		conclude_intake(false, None);
 		assert_eq!(members(), vec![10, 30]);
 		// Payout does not go to removed member
-		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts: vec![].try_into().unwrap() });
-		assert_eq!(Payouts::<Test>::get(30), PayoutRecord { paid: 0, payouts: vec![(8, 1000)].try_into().unwrap() });
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![].try_into().unwrap() }
+		);
+		assert_eq!(
+			Payouts::<Test>::get(30),
+			PayoutRecord { paid: 0, payouts: vec![(8, 1000)].try_into().unwrap() }
+		);
 	});
 }
 
@@ -1083,13 +1181,7 @@ fn zero_bid_works() {
 				(60, candidacy(1, 400, Deposit(25), 0, 0)),
 			]
 		);
-		assert_eq!(
-			Bids::<Test>::get(),
-			vec![
-				bid(20, Deposit(25), 0),
-				bid(40, Deposit(25), 0),
-			],
-		);
+		assert_eq!(Bids::<Test>::get(), vec![bid(20, Deposit(25), 0), bid(40, Deposit(25), 0),],);
 		// A member votes for these candidates to join the society
 		assert_ok!(Society::vote(Origin::signed(10), 30, true));
 		assert_ok!(Society::vote(Origin::signed(10), 50, true));
diff --git a/frame/society/src/weights.rs b/frame/society/src/weights.rs
index dc9e0d3471692..f72ef1c30f6cb 100644
--- a/frame/society/src/weights.rs
+++ b/frame/society/src/weights.rs
@@ -75,63 +75,47 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: Society SuspendedMembers (r:1 w:0)
 	// Storage: Society Parameters (r:1 w:0)
 	fn bid() -> Weight {
-		(56_738_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(5 as Weight))
-			.saturating_add(T::DbWeight::get().writes(1 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Bids (r:1 w:1)
 	fn unbid() -> Weight {
-		(45_204_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(1 as Weight))
-			.saturating_add(T::DbWeight::get().writes(1 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Bids (r:1 w:1)
 	// Storage: Society Candidates (r:1 w:0)
 	// Storage: Society Members (r:2 w:1)
 	// Storage: Society SuspendedMembers (r:1 w:0)
 	fn vouch() -> Weight {
-		(43_566_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(5 as Weight))
-			.saturating_add(T::DbWeight::get().writes(2 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Bids (r:1 w:1)
 	// Storage: Society Members (r:1 w:1)
 	fn unvouch() -> Weight {
-		(33_741_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(2 as Weight))
-			.saturating_add(T::DbWeight::get().writes(2 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Candidates (r:1 w:1)
 	// Storage: Society Members (r:1 w:0)
 	// Storage: Society Votes (r:1 w:1)
 	fn vote() -> Weight {
-		(44_890_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(3 as Weight))
-			.saturating_add(T::DbWeight::get().writes(2 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Defending (r:1 w:1)
 	// Storage: Society Members (r:1 w:0)
 	// Storage: Society ChallengeRoundCount (r:1 w:0)
 	// Storage: Society DefenderVotes (r:1 w:1)
 	fn defender_vote() -> Weight {
-		(41_752_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(4 as Weight))
-			.saturating_add(T::DbWeight::get().writes(2 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Members (r:1 w:0)
 	// Storage: Society Payouts (r:1 w:1)
 	// Storage: System Account (r:1 w:1)
 	fn payout() -> Weight {
-		(58_145_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(3 as Weight))
-			.saturating_add(T::DbWeight::get().writes(2 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Members (r:1 w:1)
 	// Storage: Society Payouts (r:1 w:1)
 	fn waive_repay() -> Weight {
-		(37_796_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(2 as Weight))
-			.saturating_add(T::DbWeight::get().writes(2 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Head (r:1 w:1)
 	// Storage: Society MemberCount (r:1 w:1)
@@ -141,9 +125,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: Society Members (r:0 w:1)
 	// Storage: Society Parameters (r:0 w:1)
 	fn found_society() -> Weight {
-		(37_221_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(2 as Weight))
-			.saturating_add(T::DbWeight::get().writes(7 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Founder (r:1 w:1)
 	// Storage: Society MemberCount (r:1 w:1)
@@ -162,26 +144,20 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: Society Parameters (r:0 w:1)
 	// Storage: Society NextHead (r:0 w:1)
 	fn dissolve() -> Weight {
-		(105_209_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(2 as Weight))
-			.saturating_add(T::DbWeight::get().writes(30 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Founder (r:1 w:0)
 	// Storage: Society SuspendedMembers (r:1 w:1)
 	// Storage: Society Payouts (r:1 w:0)
 	// Storage: Society Pot (r:1 w:1)
 	fn judge_suspended_member() -> Weight {
-		(39_916_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(4 as Weight))
-			.saturating_add(T::DbWeight::get().writes(2 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Founder (r:1 w:0)
 	// Storage: Society MemberCount (r:1 w:0)
 	// Storage: Society Parameters (r:0 w:1)
 	fn set_parameters() -> Weight {
-		(28_251_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(2 as Weight))
-			.saturating_add(T::DbWeight::get().writes(1 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Candidates (r:1 w:1)
 	// Storage: Society RoundCount (r:1 w:0)
@@ -190,9 +166,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: Society Members (r:1 w:1)
 	// Storage: Society Parameters (r:1 w:0)
 	fn punish_skeptic() -> Weight {
-		(40_041_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(6 as Weight))
-			.saturating_add(T::DbWeight::get().writes(2 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Candidates (r:1 w:1)
 	// Storage: Society RoundCount (r:1 w:0)
@@ -203,9 +177,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: Society MemberByIndex (r:0 w:1)
 	// Storage: Society Members (r:0 w:1)
 	fn claim_membership() -> Weight {
-		(64_305_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(6 as Weight))
-			.saturating_add(T::DbWeight::get().writes(6 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Founder (r:1 w:0)
 	// Storage: Society Candidates (r:1 w:1)
@@ -217,46 +189,34 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: Society MemberByIndex (r:0 w:1)
 	// Storage: Society Members (r:0 w:1)
 	fn bestow_membership() -> Weight {
-		(68_334_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(7 as Weight))
-			.saturating_add(T::DbWeight::get().writes(6 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Founder (r:1 w:0)
 	// Storage: Society Candidates (r:1 w:1)
 	// Storage: Society RoundCount (r:1 w:0)
 	fn kick_candidate() -> Weight {
-		(23_574_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(3 as Weight))
-			.saturating_add(T::DbWeight::get().writes(1 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Candidates (r:1 w:1)
 	// Storage: Society RoundCount (r:1 w:0)
 	fn resign_candidacy() -> Weight {
-		(22_284_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(2 as Weight))
-			.saturating_add(T::DbWeight::get().writes(1 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Candidates (r:1 w:1)
 	// Storage: Society RoundCount (r:1 w:0)
 	fn drop_candidate() -> Weight {
-		(32_618_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(2 as Weight))
-			.saturating_add(T::DbWeight::get().writes(1 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Candidates (r:1 w:0)
 	// Storage: Society VoteClearCursor (r:1 w:0)
 	// Storage: Society Votes (r:0 w:2)
 	fn cleanup_candidacy() -> Weight {
-		(27_936_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(2 as Weight))
-			.saturating_add(T::DbWeight::get().writes(2 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society ChallengeRoundCount (r:1 w:0)
 	// Storage: Society DefenderVotes (r:0 w:1)
 	fn cleanup_challenge() -> Weight {
-		(18_411_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(1 as Weight))
-			.saturating_add(T::DbWeight::get().writes(1 as Weight))
+		Weight::zero()
 	}
 }
 
@@ -268,63 +228,47 @@ impl WeightInfo for () {
 	// Storage: Society SuspendedMembers (r:1 w:0)
 	// Storage: Society Parameters (r:1 w:0)
 	fn bid() -> Weight {
-		(56_738_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(5 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Bids (r:1 w:1)
 	fn unbid() -> Weight {
-		(45_204_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Bids (r:1 w:1)
 	// Storage: Society Candidates (r:1 w:0)
 	// Storage: Society Members (r:2 w:1)
 	// Storage: Society SuspendedMembers (r:1 w:0)
 	fn vouch() -> Weight {
-		(43_566_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(5 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Bids (r:1 w:1)
 	// Storage: Society Members (r:1 w:1)
 	fn unvouch() -> Weight {
-		(33_741_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Candidates (r:1 w:1)
 	// Storage: Society Members (r:1 w:0)
 	// Storage: Society Votes (r:1 w:1)
 	fn vote() -> Weight {
-		(44_890_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Defending (r:1 w:1)
 	// Storage: Society Members (r:1 w:0)
 	// Storage: Society ChallengeRoundCount (r:1 w:0)
 	// Storage: Society DefenderVotes (r:1 w:1)
 	fn defender_vote() -> Weight {
-		(41_752_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(4 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Members (r:1 w:0)
 	// Storage: Society Payouts (r:1 w:1)
 	// Storage: System Account (r:1 w:1)
 	fn payout() -> Weight {
-		(58_145_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Members (r:1 w:1)
 	// Storage: Society Payouts (r:1 w:1)
 	fn waive_repay() -> Weight {
-		(37_796_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Head (r:1 w:1)
 	// Storage: Society MemberCount (r:1 w:1)
@@ -334,9 +278,7 @@ impl WeightInfo for () {
 	// Storage: Society Members (r:0 w:1)
 	// Storage: Society Parameters (r:0 w:1)
 	fn found_society() -> Weight {
-		(37_221_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(7 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Founder (r:1 w:1)
 	// Storage: Society MemberCount (r:1 w:1)
@@ -355,26 +297,20 @@ impl WeightInfo for () {
 	// Storage: Society Parameters (r:0 w:1)
 	// Storage: Society NextHead (r:0 w:1)
 	fn dissolve() -> Weight {
-		(105_209_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(30 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Founder (r:1 w:0)
 	// Storage: Society SuspendedMembers (r:1 w:1)
 	// Storage: Society Payouts (r:1 w:0)
 	// Storage: Society Pot (r:1 w:1)
 	fn judge_suspended_member() -> Weight {
-		(39_916_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(4 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Founder (r:1 w:0)
 	// Storage: Society MemberCount (r:1 w:0)
 	// Storage: Society Parameters (r:0 w:1)
 	fn set_parameters() -> Weight {
-		(28_251_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Candidates (r:1 w:1)
 	// Storage: Society RoundCount (r:1 w:0)
@@ -383,9 +319,7 @@ impl WeightInfo for () {
 	// Storage: Society Members (r:1 w:1)
 	// Storage: Society Parameters (r:1 w:0)
 	fn punish_skeptic() -> Weight {
-		(40_041_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(6 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Candidates (r:1 w:1)
 	// Storage: Society RoundCount (r:1 w:0)
@@ -396,9 +330,7 @@ impl WeightInfo for () {
 	// Storage: Society MemberByIndex (r:0 w:1)
 	// Storage: Society Members (r:0 w:1)
 	fn claim_membership() -> Weight {
-		(64_305_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(6 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(6 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Founder (r:1 w:0)
 	// Storage: Society Candidates (r:1 w:1)
@@ -410,45 +342,33 @@ impl WeightInfo for () {
 	// Storage: Society MemberByIndex (r:0 w:1)
 	// Storage: Society Members (r:0 w:1)
 	fn bestow_membership() -> Weight {
-		(68_334_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(7 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(6 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Founder (r:1 w:0)
 	// Storage: Society Candidates (r:1 w:1)
 	// Storage: Society RoundCount (r:1 w:0)
 	fn kick_candidate() -> Weight {
-		(23_574_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Candidates (r:1 w:1)
 	// Storage: Society RoundCount (r:1 w:0)
 	fn resign_candidacy() -> Weight {
-		(22_284_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Candidates (r:1 w:1)
 	// Storage: Society RoundCount (r:1 w:0)
 	fn drop_candidate() -> Weight {
-		(32_618_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society Candidates (r:1 w:0)
 	// Storage: Society VoteClearCursor (r:1 w:0)
 	// Storage: Society Votes (r:0 w:2)
 	fn cleanup_candidacy() -> Weight {
-		(27_936_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
+		Weight::zero()
 	}
 	// Storage: Society ChallengeRoundCount (r:1 w:0)
 	// Storage: Society DefenderVotes (r:0 w:1)
 	fn cleanup_challenge() -> Weight {
-		(18_411_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
+		Weight::zero()
 	}
 }
diff --git a/frame/support/src/storage/mod.rs b/frame/support/src/storage/mod.rs
index d80058c2824a3..90249561bd236 100644
--- a/frame/support/src/storage/mod.rs
+++ b/frame/support/src/storage/mod.rs
@@ -196,11 +196,10 @@ pub trait StorageMap<K: FullEncode, V: FullCodec> {
 
 	/// Mutate the value under a key if the value already exists. Do nothing and return the default
 	/// value if not.
-	fn mutate_extant<
-		KeyArg: EncodeLike<K>,
-		R: Default,
-		F: FnOnce(&mut V) -> R,
-	>(key: KeyArg, f: F) -> R {
+	fn mutate_extant<KeyArg: EncodeLike<K>, R: Default, F: FnOnce(&mut V) -> R>(
+		key: KeyArg,
+		f: F,
+	) -> R {
 		Self::mutate_exists(key, |maybe_v| match maybe_v {
 			Some(ref mut value) => f(value),
 			None => R::default(),
diff --git a/frame/support/src/storage/types/map.rs b/frame/support/src/storage/types/map.rs
index 7655922761051..fa1e92b8019c6 100644
--- a/frame/support/src/storage/types/map.rs
+++ b/frame/support/src/storage/types/map.rs
@@ -378,7 +378,9 @@ where
 	/// particular order.
 	///
 	/// If you alter the map while doing this, you'll get undefined results.
-	pub fn iter_from_key(starting_key: impl EncodeLike<Key>) -> crate::storage::PrefixIterator<(Key, Value)> {
+	pub fn iter_from_key(
+		starting_key: impl EncodeLike<Key>,
+	) -> crate::storage::PrefixIterator<(Key, Value)> {
 		Self::iter_from(Self::hashed_key_for(starting_key))
 	}
 
@@ -401,7 +403,9 @@ where
 	/// order.
 	///
 	/// If you alter the map while doing this, you'll get undefined results.
-	pub fn iter_keys_from_key(starting_key: impl EncodeLike<Key>) -> crate::storage::KeyPrefixIterator<Key> {
+	pub fn iter_keys_from_key(
+		starting_key: impl EncodeLike<Key>,
+	) -> crate::storage::KeyPrefixIterator<Key> {
 		Self::iter_keys_from(Self::hashed_key_for(starting_key))
 	}
 
diff --git a/primitives/core/src/ed25519.rs b/primitives/core/src/ed25519.rs
index 27090112ff5e5..9c0bd8c0d4bdf 100644
--- a/primitives/core/src/ed25519.rs
+++ b/primitives/core/src/ed25519.rs
@@ -32,8 +32,8 @@ use scale_info::TypeInfo;
 #[cfg(feature = "std")]
 use crate::crypto::Ss58Codec;
 use crate::crypto::{
-	CryptoType, CryptoTypeId, CryptoTypePublicPair, Derive, Public as TraitPublic, UncheckedFrom,
-	FromEntropy,
+	CryptoType, CryptoTypeId, CryptoTypePublicPair, Derive, FromEntropy, Public as TraitPublic,
+	UncheckedFrom,
 };
 #[cfg(feature = "full_crypto")]
 use crate::crypto::{DeriveJunction, Pair as TraitPair, SecretStringError};
diff --git a/primitives/core/src/sr25519.rs b/primitives/core/src/sr25519.rs
index 79784a79d035c..1cba83c610f40 100644
--- a/primitives/core/src/sr25519.rs
+++ b/primitives/core/src/sr25519.rs
@@ -39,8 +39,8 @@ use substrate_bip39::mini_secret_from_entropy;
 
 use crate::{
 	crypto::{
-		ByteArray, CryptoType, CryptoTypeId, CryptoTypePublicPair, Derive, Public as TraitPublic,
-		UncheckedFrom, FromEntropy,
+		ByteArray, CryptoType, CryptoTypeId, CryptoTypePublicPair, Derive, FromEntropy,
+		Public as TraitPublic, UncheckedFrom,
 	},
 	hash::{H256, H512},
 };

From d9dce35ac7410c5cfab82eba7e91faad32e122da Mon Sep 17 00:00:00 2001
From: Gav <gavin@parity.io>
Date: Wed, 7 Dec 2022 16:26:24 +0000
Subject: [PATCH 27/43] Fixes

---
 frame/society/Cargo.toml          |  6 ++++--
 frame/society/src/benchmarking.rs | 18 +++++++++++-------
 2 files changed, 15 insertions(+), 9 deletions(-)

diff --git a/frame/society/Cargo.toml b/frame/society/Cargo.toml
index 6b5eb0fce31b6..9cb4fd12bcc09 100644
--- a/frame/society/Cargo.toml
+++ b/frame/society/Cargo.toml
@@ -16,10 +16,10 @@ targets = ["x86_64-unknown-linux-gnu"]
 codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] }
 rand_chacha = { version = "0.2", default-features = false }
 scale-info = { version = "2.1.1", default-features = false, features = ["derive"] }
-sp-runtime = { version = "7.0.0", default-features = false, path = "../../primitives/runtime" }
 sp-std = { version = "5.0.0", default-features = false, path = "../../primitives/std" }
 sp-io = { version = "7.0.0", default-features = false, path = "../../primitives/io" }
 sp-arithmetic = { version = "6.0.0", default-features = false, path = "../../primitives/arithmetic" }
+sp-runtime = { version = "7.0.0", default-features = false, path = "../../primitives/runtime" }
 frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
 frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
 frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
@@ -44,8 +44,10 @@ std = [
 	"sp-io/std",
 ]
 runtime-benchmarks = [
-	"frame-system/runtime-benchmarks",
 	"sp-runtime/runtime-benchmarks",
 	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
 ]
 try-runtime = ["frame-support/try-runtime"]
diff --git a/frame/society/src/benchmarking.rs b/frame/society/src/benchmarking.rs
index 4cd4abe5952dc..8ef6d0751977f 100644
--- a/frame/society/src/benchmarking.rs
+++ b/frame/society/src/benchmarking.rs
@@ -36,12 +36,13 @@ fn mock_balance_deposit<T: Config<I>, I: 'static>() -> BalanceOf<T, I> {
 fn setup_society<T: Config<I>, I: 'static>() -> Result<T::AccountId, &'static str> {
 	let origin = T::FounderSetOrigin::successful_origin();
 	let founder: T::AccountId = account("founder", 0, 0);
+	let founder_lookup: <T::Lookup as StaticLookup>::Source = T::Lookup::unlookup(founder.clone());
 	let max_members = 5u32;
 	let max_intake = 3u32;
 	let max_strikes = 3u32;
 	Society::<T, I>::found_society(
 		origin,
-		founder.clone(),
+		founder_lookup,
 		max_members,
 		max_intake,
 		max_strikes,
@@ -108,7 +109,8 @@ benchmarks_instance_pallet! {
 		let vouched: T::AccountId = account("vouched", 0, 0);
 		T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
 		let _ = Society::<T, I>::insert_member(&caller, 1u32.into());
-	}: _(RawOrigin::Signed(caller.clone()), vouched.clone(), 0u32.into(), 0u32.into())
+		let vouched_lookup: <T::Lookup as StaticLookup>::Source = T::Lookup::unlookup(vouched.clone());
+	}: _(RawOrigin::Signed(caller.clone()), vouched_lookup, 0u32.into(), 0u32.into())
 	verify {
 		let bids = Bids::<T, I>::get();
 		let vouched_bid: Bid<T::AccountId, BalanceOf<T, I>> = Bid {
@@ -191,7 +193,8 @@ benchmarks_instance_pallet! {
 	found_society {
 		let founder: T::AccountId = whitelisted_caller();
 		let can_found = T::FounderSetOrigin::successful_origin();
-	}: _<T::Origin>(can_found, founder.clone(), 5, 3, 3, mock_balance_deposit::<T, I>(), b"benchmarking-society".to_vec())
+		let founder_lookup: <T::Lookup as StaticLookup>::Source = T::Lookup::unlookup(founder.clone());
+	}: _<T::RuntimeOrigin>(can_found, founder_lookup, 5, 3, 3, mock_balance_deposit::<T, I>(), b"benchmarking-society".to_vec())
 	verify {
 		assert_eq!(Founder::<T, I>::get(), Some(founder.clone()));
 	}
@@ -217,9 +220,10 @@ benchmarks_instance_pallet! {
 	judge_suspended_member {
 		let founder = setup_society::<T, I>()?;
 		let caller: T::AccountId = whitelisted_caller();
+		let caller_lookup: <T::Lookup as StaticLookup>::Source = T::Lookup::unlookup(caller.clone());
 		let _ = Society::<T, I>::insert_member(&caller, 0u32.into());
 		let _ = Society::<T, I>::suspend_member(&caller);
-	}: _(RawOrigin::Signed(founder), caller.clone(), false)
+	}: _(RawOrigin::Signed(founder), caller_lookup, false)
 	verify {
 		assert_eq!(SuspendedMembers::<T, I>::contains_key(&caller), false);
 	}
@@ -333,7 +337,7 @@ benchmarks_instance_pallet! {
 
 	impl_benchmark_test_suite!(
 		Society,
-		crate::tests_composite::ExtBuilder::default().build(),
-		crate::tests_composite::Test,
-	)
+		sp_io::TestExternalities::from(frame_system::GenesisConfig::default().build_storage::<crate::mock::Test>().unwrap()),
+		crate::mock::Test
+	);
 }

From 4c60eef62ba0c98b0d3b89002060b387db32be68 Mon Sep 17 00:00:00 2001
From: Gav <gavin@parity.io>
Date: Thu, 8 Dec 2022 13:36:22 +0000
Subject: [PATCH 28/43] Spelling

---
 frame/democracy/src/vote.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/frame/democracy/src/vote.rs b/frame/democracy/src/vote.rs
index 122f54febd8cf..be3b7c50adacb 100644
--- a/frame/democracy/src/vote.rs
+++ b/frame/democracy/src/vote.rs
@@ -202,7 +202,7 @@ impl<
 		.rejig(now);
 	}
 
-	/// The amount of this account's balance that much currently be locked due to voting.
+	/// The amount of this account's balance that must currently be locked due to voting.
 	pub fn locked_balance(&self) -> Balance {
 		match self {
 			Voting::Direct { votes, prior, .. } =>

From 3f119f1b892cf701bf558f3955039fedc426a560 Mon Sep 17 00:00:00 2001
From: Gav <gavin@parity.io>
Date: Mon, 12 Jun 2023 12:15:55 +0100
Subject: [PATCH 29/43] Fix benchmarks

---
 Cargo.lock                        |  4 +-
 frame/society/src/benchmarking.rs | 61 ++++++++++++++++++++++++-------
 frame/society/src/lib.rs          |  1 +
 primitives/core/Cargo.toml        |  2 +-
 primitives/core/src/ed25519.rs    |  4 +-
 primitives/core/src/sr25519.rs    |  5 ++-
 6 files changed, 58 insertions(+), 19 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4a0b113dedb8d..a9edfd6f12c7d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -979,9 +979,9 @@ checksum = "8d696c370c750c948ada61c69a0ee2cbbb9c50b1019ddb86d9317157a99c2cae"
 
 [[package]]
 name = "bounded-collections"
-version = "0.1.7"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07fbd1d11282a1eb134d3c3b7cf8ce213b5161c6e5f73fb1b98618482c606b64"
+checksum = "eb5b05133427c07c4776906f673ccf36c21b102c9829c641a5b56bd151d44fd6"
 dependencies = [
  "log",
  "parity-scale-codec",
diff --git a/frame/society/src/benchmarking.rs b/frame/society/src/benchmarking.rs
index 8ef6d0751977f..2f1dfe021be1f 100644
--- a/frame/society/src/benchmarking.rs
+++ b/frame/society/src/benchmarking.rs
@@ -32,9 +32,33 @@ fn mock_balance_deposit<T: Config<I>, I: 'static>() -> BalanceOf<T, I> {
 	T::Currency::minimum_balance().saturating_mul(1_000u32.into())
 }
 
+fn make_deposit<T: Config<I>, I: 'static>(who: &T::AccountId) -> BalanceOf<T, I> {
+	let amount = mock_balance_deposit::<T, I>();
+	let required = amount.saturating_add(T::Currency::minimum_balance());
+	if T::Currency::free_balance(who) < required {
+		T::Currency::make_free_balance_be(who, required);
+	}
+	T::Currency::reserve(who, amount).expect("Pre-funded account; qed");
+	amount
+}
+
+fn make_bid<T: Config<I>, I: 'static>(
+	who: &T::AccountId,
+) -> BidKind<T::AccountId, BalanceOf<T, I>> {
+	BidKind::Deposit(make_deposit::<T, I>(who))
+}
+
+fn fund_society<T: Config<I>, I: 'static>() {
+	T::Currency::make_free_balance_be(
+		&Society::<T, I>::account_id(),
+		BalanceOf::<T, I>::max_value(),
+	);
+	Pot::<T, I>::put(&BalanceOf::<T, I>::max_value());
+}
+
 // Set up Society
 fn setup_society<T: Config<I>, I: 'static>() -> Result<T::AccountId, &'static str> {
-	let origin = T::FounderSetOrigin::successful_origin();
+	let origin = T::FounderSetOrigin::try_successful_origin().map_err(|_| "No origin")?;
 	let founder: T::AccountId = account("founder", 0, 0);
 	let founder_lookup: <T::Lookup as StaticLookup>::Source = T::Lookup::unlookup(founder.clone());
 	let max_members = 5u32;
@@ -49,6 +73,16 @@ fn setup_society<T: Config<I>, I: 'static>() -> Result<T::AccountId, &'static st
 		mock_balance_deposit::<T, I>(),
 		b"benchmarking-society".to_vec(),
 	)?;
+	T::Currency::make_free_balance_be(
+		&Society::<T, I>::account_id(),
+		T::Currency::minimum_balance(),
+	);
+	Ok(founder)
+}
+
+fn setup_funded_society<T: Config<I>, I: 'static>() -> Result<T::AccountId, &'static str> {
+	let founder = setup_society::<T, I>()?;
+	fund_society::<T, I>();
 	Ok(founder)
 }
 
@@ -58,10 +92,9 @@ fn add_candidate<T: Config<I>, I: 'static>(
 	skeptic_struck: bool,
 ) -> T::AccountId {
 	let candidate: T::AccountId = account(name, 0, 0);
-	T::Currency::make_free_balance_be(&candidate, BalanceOf::<T, I>::max_value());
 	let candidacy = Candidacy {
 		round: RoundCount::<T, I>::get(),
-		kind: BidKind::Deposit(mock_balance_deposit::<T, I>()),
+		kind: make_bid::<T, I>(&candidate),
 		bid: 0u32.into(),
 		tally,
 		skeptic_struck,
@@ -92,11 +125,12 @@ benchmarks_instance_pallet! {
 	}
 
 	unbid {
+		println!("MD: {:?}", mock_balance_deposit::<T, I>());
 		let founder = setup_society::<T, I>()?;
 		let caller: T::AccountId = whitelisted_caller();
 		T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
 		let mut bids = Bids::<T, I>::get();
-		Society::<T, I>::insert_bid(&mut bids, &caller, 10u32.into(), BidKind::Deposit(mock_balance_deposit::<T, I>()));
+		Society::<T, I>::insert_bid(&mut bids, &caller, 10u32.into(), make_bid::<T, I>(&caller));
 		Bids::<T, I>::put(bids);
 	}: _(RawOrigin::Signed(caller.clone()))
 	verify {
@@ -162,14 +196,12 @@ benchmarks_instance_pallet! {
 	}
 
 	payout {
-		let founder = setup_society::<T, I>()?;
+		let founder = setup_funded_society::<T, I>()?;
+		// Payee's account already exists and is a member.
 		let caller: T::AccountId = whitelisted_caller();
 		T::Currency::make_free_balance_be(&caller, mock_balance_deposit::<T, I>());
 		let _ = Society::<T, I>::insert_member(&caller, 0u32.into());
-		T::Currency::make_free_balance_be(&Society::<T, I>::payouts(), BalanceOf::<T, I>::max_value());
-		let mut pot = <Pot<T, I>>::get();
-		pot = pot.saturating_add(BalanceOf::<T, I>::max_value());
-		Pot::<T, I>::put(&pot);
+		// Introduce payout.
 		Society::<T, I>::bump_payout(&caller, 0u32.into(), 1u32.into());
 	}: _(RawOrigin::Signed(caller.clone()))
 	verify {
@@ -178,11 +210,10 @@ benchmarks_instance_pallet! {
 	}
 
 	waive_repay {
-		let founder = setup_society::<T, I>()?;
+		let founder = setup_funded_society::<T, I>()?;
 		let caller: T::AccountId = whitelisted_caller();
 		T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
 		let _ = Society::<T, I>::insert_member(&caller, 0u32.into());
-		T::Currency::make_free_balance_be(&Society::<T, I>::payouts(), BalanceOf::<T, I>::max_value());
 		Society::<T, I>::bump_payout(&caller, 0u32.into(), 1u32.into());
 	}: _(RawOrigin::Signed(caller.clone()), 1u32.into())
 	verify {
@@ -192,7 +223,7 @@ benchmarks_instance_pallet! {
 
 	found_society {
 		let founder: T::AccountId = whitelisted_caller();
-		let can_found = T::FounderSetOrigin::successful_origin();
+		let can_found = T::FounderSetOrigin::try_successful_origin().map_err(|_| "No origin")?;
 		let founder_lookup: <T::Lookup as StaticLookup>::Source = T::Lookup::unlookup(founder.clone());
 	}: _<T::RuntimeOrigin>(can_found, founder_lookup, 5, 3, 3, mock_balance_deposit::<T, I>(), b"benchmarking-society".to_vec())
 	verify {
@@ -246,8 +277,10 @@ benchmarks_instance_pallet! {
 		let skeptic: T::AccountId = account("skeptic", 0, 0);
 		let _ = Society::<T, I>::insert_member(&skeptic, 0u32.into());
 		Skeptic::<T, I>::put(&skeptic);
-		frame_system::Pallet::<T>::set_block_number(T::VotingPeriod::get() + 1u32.into());
-	}: _(RawOrigin::Signed(candidate.clone()))
+		if let Period::Voting { more, .. } = Society::<T, I>::period() {
+			frame_system::Pallet::<T>::set_block_number(frame_system::Pallet::<T>::block_number() + more);
+		}
+		}: _(RawOrigin::Signed(candidate.clone()))
 	verify {
 		let candidacy = Candidates::<T, I>::get(&candidate).unwrap();
 		assert_eq!(candidacy.skeptic_struck, true);
diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index a1954758b4d02..427856b8b131e 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -1380,6 +1380,7 @@ pub mod pallet {
 		/// Remove up to `max` stale votes for the defender in the given `challenge_round`.
 		///
 		/// May be called by any Signed origin, but only after the challenge round is ended.
+		#[pallet::call_index(19)]
 		#[pallet::weight(T::WeightInfo::cleanup_challenge())]
 		pub fn cleanup_challenge(
 			origin: OriginFor<T>,
diff --git a/primitives/core/Cargo.toml b/primitives/core/Cargo.toml
index 98df775d289c1..6c043d5a21499 100644
--- a/primitives/core/Cargo.toml
+++ b/primitives/core/Cargo.toml
@@ -17,7 +17,7 @@ codec = { package = "parity-scale-codec", version = "3.2.2", default-features =
 scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
 log = { version = "0.4.17", default-features = false }
 serde = { version = "1.0.163", optional = true,  default-features = false, features = ["derive", "alloc"] }
-bounded-collections = { version = "0.1.7", default-features = false }
+bounded-collections = { version = "0.1.8", default-features = false }
 primitive-types = { version = "0.12.0", default-features = false, features = ["codec", "scale-info"] }
 impl-serde = { version = "0.4.0", default-features = false, optional = true }
 hash-db = { version = "0.16.0", default-features = false }
diff --git a/primitives/core/src/ed25519.rs b/primitives/core/src/ed25519.rs
index 87213aca9bf89..ba947990e1c0b 100644
--- a/primitives/core/src/ed25519.rs
+++ b/primitives/core/src/ed25519.rs
@@ -31,7 +31,9 @@ use scale_info::TypeInfo;
 
 #[cfg(feature = "serde")]
 use crate::crypto::Ss58Codec;
-use crate::crypto::{CryptoType, CryptoTypeId, Derive, FromEntropy, Public as TraitPublic, UncheckedFrom};
+use crate::crypto::{
+	CryptoType, CryptoTypeId, Derive, FromEntropy, Public as TraitPublic, UncheckedFrom,
+};
 #[cfg(feature = "full_crypto")]
 use crate::crypto::{DeriveError, DeriveJunction, Pair as TraitPair, SecretStringError};
 #[cfg(feature = "full_crypto")]
diff --git a/primitives/core/src/sr25519.rs b/primitives/core/src/sr25519.rs
index e1abbb4ce296a..963ca1c3fedc3 100644
--- a/primitives/core/src/sr25519.rs
+++ b/primitives/core/src/sr25519.rs
@@ -37,7 +37,10 @@ use schnorrkel::{
 use sp_std::vec::Vec;
 
 use crate::{
-	crypto::{ByteArray, CryptoType, CryptoTypeId, Derive, FromEntropy, Public as TraitPublic, UncheckedFrom},
+	crypto::{
+		ByteArray, CryptoType, CryptoTypeId, Derive, FromEntropy, Public as TraitPublic,
+		UncheckedFrom,
+	},
 	hash::{H256, H512},
 };
 use codec::{Decode, Encode, MaxEncodedLen};

From 2440062c8923b31ab33ac0c5c649c4ff2ce59859 Mon Sep 17 00:00:00 2001
From: Gav <gavin@parity.io>
Date: Mon, 12 Jun 2023 12:18:32 +0100
Subject: [PATCH 30/43] Another fix

---
 frame/society/src/lib.rs | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index 6d5b52a82ad9d..c8e87c9fd7229 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -262,13 +262,8 @@ use frame_support::{
 	pallet_prelude::*,
 	storage::KeyLenOf,
 	traits::{
-<<<<<<< HEAD
-		BalanceStatus, Currency, EnsureOrigin, ExistenceRequirement::AllowDeath, Imbalance,
-		OnUnbalanced, Randomness, ReservableCurrency,
-=======
-		BalanceStatus, ChangeMembers, Currency, EnsureOrigin, EnsureOriginWithArg,
+		BalanceStatus, Currency, EnsureOrigin, EnsureOriginWithArg,
 		ExistenceRequirement::AllowDeath, Imbalance, OnUnbalanced, Randomness, ReservableCurrency,
->>>>>>> origin/master
 	},
 	PalletId,
 };

From 7811ac156a02cc8f3e9133c1ab306c9c375e3386 Mon Sep 17 00:00:00 2001
From: Gav <gavin@parity.io>
Date: Mon, 12 Jun 2023 12:31:03 +0100
Subject: [PATCH 31/43] Remove println

---
 frame/society/src/benchmarking.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/frame/society/src/benchmarking.rs b/frame/society/src/benchmarking.rs
index 2f1dfe021be1f..f690abc5745a3 100644
--- a/frame/society/src/benchmarking.rs
+++ b/frame/society/src/benchmarking.rs
@@ -125,7 +125,6 @@ benchmarks_instance_pallet! {
 	}
 
 	unbid {
-		println!("MD: {:?}", mock_balance_deposit::<T, I>());
 		let founder = setup_society::<T, I>()?;
 		let caller: T::AccountId = whitelisted_caller();
 		T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());

From 687d91436316d803bb972abcf0dd96800736f11a Mon Sep 17 00:00:00 2001
From: Gav <gavin@parity.io>
Date: Mon, 12 Jun 2023 18:49:34 +0100
Subject: [PATCH 32/43] Society migration

---
 Cargo.lock                        |  1 +
 frame/society/Cargo.toml          |  1 +
 frame/society/src/benchmarking.rs |  4 +++
 frame/society/src/migrations.rs   | 43 ++++++++++++++++++++++++++++---
 4 files changed, 46 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a9edfd6f12c7d..a91d643d4564d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -7289,6 +7289,7 @@ dependencies = [
  "frame-support-test",
  "frame-system",
  "hex-literal",
+ "log",
  "pallet-balances",
  "parity-scale-codec",
  "rand_chacha 0.2.2",
diff --git a/frame/society/Cargo.toml b/frame/society/Cargo.toml
index 23a8cacc17301..7bd2124f132f9 100644
--- a/frame/society/Cargo.toml
+++ b/frame/society/Cargo.toml
@@ -14,6 +14,7 @@ targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
 codec = { package = "parity-scale-codec", version = "3.2.2", default-features = false, features = ["derive"] }
+log = { version = "0.4.17", default-features = false }
 rand_chacha = { version = "0.2", default-features = false }
 scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
 sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
diff --git a/frame/society/src/benchmarking.rs b/frame/society/src/benchmarking.rs
index f690abc5745a3..a7ad6b4a65864 100644
--- a/frame/society/src/benchmarking.rs
+++ b/frame/society/src/benchmarking.rs
@@ -77,6 +77,10 @@ fn setup_society<T: Config<I>, I: 'static>() -> Result<T::AccountId, &'static st
 		&Society::<T, I>::account_id(),
 		T::Currency::minimum_balance(),
 	);
+	T::Currency::make_free_balance_be(
+		&Society::<T, I>::payouts(),
+		T::Currency::minimum_balance(),
+	);
 	Ok(founder)
 }
 
diff --git a/frame/society/src/migrations.rs b/frame/society/src/migrations.rs
index 8691e4d59b317..f4c52e2b02c47 100644
--- a/frame/society/src/migrations.rs
+++ b/frame/society/src/migrations.rs
@@ -18,7 +18,41 @@
 //! # Migrations for Society Pallet
 
 use super::*;
-use frame_support::traits::Instance;
+use frame_support::traits::{Instance, OnRuntimeUpgrade};
+
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+
+/// The log target.
+const TARGET: &'static str = "runtime::society::migration";
+
+/// This migration moves all the state to v2 of Society.
+pub struct MigrateToV2<T: Config<I>, I: 'static, PastPayouts>(sp_std::marker::PhantomData<(T, I, PastPayouts)>);
+
+impl<
+	T: Config<I>,
+	I: Instance + 'static,
+	PastPayouts: Get<Vec<(<T as frame_system::Config>::AccountId, BalanceOf<T, I>)>>
+> OnRuntimeUpgrade for MigrateToV2<T, I, PastPayouts> {
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+		assert!(
+			can_migrate(),
+			"Invalid (perhaps already-migrated) state detected prior to migration"
+		);
+		Ok(Vec::new())
+	}
+
+	fn on_runtime_upgrade() -> Weight {
+		from_original::<T, I>(&mut PastPayouts::get())
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade(_: Vec<u8>) -> Result<(), TryRuntimeError> {
+		assert_internal_consistency::<T, I>();
+		Ok(())
+	}
+}
 
 pub(crate) mod old {
 	use super::*;
@@ -160,12 +194,13 @@ pub fn assert_internal_consistency<T: Config<I>, I: Instance + 'static>() {
 
 pub fn from_original<T: Config<I>, I: Instance + 'static>(
 	past_payouts: &mut [(<T as frame_system::Config>::AccountId, BalanceOf<T, I>)],
-) {
+) -> Weight {
 	// First check that this is the original state layout. This is easy since the original layout
 	// contained the Members value, and this value no longer exists in the new layout.
 	if !old::Members::<T, I>::exists() {
+		log::warn!(target: TARGET, "Skipping MigrateToV2 migration since it appears unapplicable");
 		// Already migrated or no data to migrate: Bail.
-		return
+		return T::DbWeight::get().reads(1)
 	}
 
 	// Migrate Bids from old::Bids (just a trunctation).
@@ -240,6 +275,8 @@ pub fn from_original<T: Config<I>, I: Instance + 'static>(
 	// We give the current defender the benefit of the doubt.
 	old::Defender::<T, I>::kill();
 	let _ = old::DefenderVotes::<T, I>::clear(u32::MAX, None);
+
+	T::BlockWeights::get().max_block
 }
 
 pub fn from_raw_past_payouts<T: Config<I>, I: Instance + 'static>(

From ab1eafdb1f171e4c39b948304236507ac5c67cd8 Mon Sep 17 00:00:00 2001
From: Gav <gavin@parity.io>
Date: Tue, 13 Jun 2023 19:16:17 +0100
Subject: [PATCH 33/43] Fixes

---
 frame/society/src/benchmarking.rs |  5 +----
 frame/society/src/lib.rs          |  3 ++-
 frame/society/src/migrations.rs   | 18 ++++++++++--------
 frame/society/src/tests.rs        |  3 +++
 4 files changed, 16 insertions(+), 13 deletions(-)

diff --git a/frame/society/src/benchmarking.rs b/frame/society/src/benchmarking.rs
index a7ad6b4a65864..1d6f44a1064da 100644
--- a/frame/society/src/benchmarking.rs
+++ b/frame/society/src/benchmarking.rs
@@ -77,10 +77,7 @@ fn setup_society<T: Config<I>, I: 'static>() -> Result<T::AccountId, &'static st
 		&Society::<T, I>::account_id(),
 		T::Currency::minimum_balance(),
 	);
-	T::Currency::make_free_balance_be(
-		&Society::<T, I>::payouts(),
-		T::Currency::minimum_balance(),
-	);
+	T::Currency::make_free_balance_be(&Society::<T, I>::payouts(), T::Currency::minimum_balance());
 	Ok(founder)
 }
 
diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index c8e87c9fd7229..48ab159f7cbf7 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -1700,7 +1700,8 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 			BidKind::Deposit(deposit) => {
 				let pot = Self::account_id();
 				let free = BalanceStatus::Free;
-				debug_assert!(T::Currency::repatriate_reserved(&who, &pot, *deposit, free).is_ok());
+				let r = T::Currency::repatriate_reserved(&who, &pot, *deposit, free);
+				debug_assert!(r.is_ok());
 			},
 			BidKind::Vouch(voucher, _) => {
 				Members::<T, I>::mutate_extant(voucher, |record| {
diff --git a/frame/society/src/migrations.rs b/frame/society/src/migrations.rs
index f4c52e2b02c47..0974de9a4a51b 100644
--- a/frame/society/src/migrations.rs
+++ b/frame/society/src/migrations.rs
@@ -27,13 +27,16 @@ use sp_runtime::TryRuntimeError;
 const TARGET: &'static str = "runtime::society::migration";
 
 /// This migration moves all the state to v2 of Society.
-pub struct MigrateToV2<T: Config<I>, I: 'static, PastPayouts>(sp_std::marker::PhantomData<(T, I, PastPayouts)>);
+pub struct MigrateToV2<T: Config<I>, I: 'static, PastPayouts>(
+	sp_std::marker::PhantomData<(T, I, PastPayouts)>,
+);
 
 impl<
-	T: Config<I>,
-	I: Instance + 'static,
-	PastPayouts: Get<Vec<(<T as frame_system::Config>::AccountId, BalanceOf<T, I>)>>
-> OnRuntimeUpgrade for MigrateToV2<T, I, PastPayouts> {
+		T: Config<I>,
+		I: Instance + 'static,
+		PastPayouts: Get<Vec<(<T as frame_system::Config>::AccountId, BalanceOf<T, I>)>>,
+	> OnRuntimeUpgrade for MigrateToV2<T, I, PastPayouts>
+{
 	#[cfg(feature = "try-runtime")]
 	fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
 		assert!(
@@ -280,11 +283,10 @@ pub fn from_original<T: Config<I>, I: Instance + 'static>(
 }
 
 pub fn from_raw_past_payouts<T: Config<I>, I: Instance + 'static>(
-	past_payouts_raw: &[(&[u8], u128)],
+	past_payouts_raw: impl Iterator<Item = ([u8; 32], u128)>,
 ) -> Vec<(<T as frame_system::Config>::AccountId, BalanceOf<T, I>)> {
 	past_payouts_raw
-		.iter()
-		.filter_map(|(x, y)| Some((Decode::decode(&mut x.as_ref()).ok()?, (*y).try_into().ok()?)))
+		.filter_map(|(x, y)| Some((Decode::decode(&mut &x[..]).ok()?, y.try_into().ok()?)))
 		.collect()
 }
 
diff --git a/frame/society/src/tests.rs b/frame/society/src/tests.rs
index 67e9829e8b0d5..4a90ad52112d8 100644
--- a/frame/society/src/tests.rs
+++ b/frame/society/src/tests.rs
@@ -566,6 +566,9 @@ fn suspended_candidate_rejected_works() {
 		assert_eq!(Balances::reserved_balance(50), 0);
 		assert_eq!(Balances::free_balance(Society::account_id()), 9980);
 
+		assert_eq!(Balances::free_balance(70), 25);
+		assert_eq!(Balances::reserved_balance(70), 25);
+
 		assert_ok!(Society::kick_candidate(Origin::signed(10), 70));
 		assert_eq!(members(), vec![10, 20, 30, 40, 50]);
 		assert_eq!(candidates(), vec![60]);

From c01e8bc898600061a92ee2f42e6568e9dde3b2a4 Mon Sep 17 00:00:00 2001
From: Gav <gavin@parity.io>
Date: Tue, 13 Jun 2023 19:33:43 +0100
Subject: [PATCH 34/43] Docs

---
 frame/asset-conversion/src/benchmarking.rs      | 2 +-
 frame/core-fellowship/src/benchmarking.rs       | 2 +-
 frame/nft-fractionalization/src/benchmarking.rs | 2 +-
 frame/salary/src/benchmarking.rs                | 2 +-
 frame/society/src/benchmarking.rs               | 2 +-
 frame/society/src/migrations.rs                 | 2 +-
 6 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/frame/asset-conversion/src/benchmarking.rs b/frame/asset-conversion/src/benchmarking.rs
index 0563a8543f087..0a212fb5ceeb4 100644
--- a/frame/asset-conversion/src/benchmarking.rs
+++ b/frame/asset-conversion/src/benchmarking.rs
@@ -1,6 +1,6 @@
 // This file is part of Substrate.
 
-// Copyright (C) 2020-2022 Parity Technologies (UK) Ltd.
+// Copyright (C) Parity Technologies (UK) Ltd.
 // SPDX-License-Identifier: Apache-2.0
 
 // Licensed under the Apache License, Version 2.0 (the "License");
diff --git a/frame/core-fellowship/src/benchmarking.rs b/frame/core-fellowship/src/benchmarking.rs
index 551ec30c19f01..c49f50d4cc115 100644
--- a/frame/core-fellowship/src/benchmarking.rs
+++ b/frame/core-fellowship/src/benchmarking.rs
@@ -1,6 +1,6 @@
 // This file is part of Substrate.
 
-// Copyright (C) 2020-2022 Parity Technologies (UK) Ltd.
+// Copyright (C) Parity Technologies (UK) Ltd.
 // SPDX-License-Identifier: Apache-2.0
 
 // Licensed under the Apache License, Version 2.0 (the "License");
diff --git a/frame/nft-fractionalization/src/benchmarking.rs b/frame/nft-fractionalization/src/benchmarking.rs
index 1600ae78c4bdf..50bb6039eb6ec 100644
--- a/frame/nft-fractionalization/src/benchmarking.rs
+++ b/frame/nft-fractionalization/src/benchmarking.rs
@@ -1,6 +1,6 @@
 // This file is part of Substrate.
 
-// Copyright (C) 2020-2022 Parity Technologies (UK) Ltd.
+// Copyright (C) Parity Technologies (UK) Ltd.
 // SPDX-License-Identifier: Apache-2.0
 
 // Licensed under the Apache License, Version 2.0 (the "License");
diff --git a/frame/salary/src/benchmarking.rs b/frame/salary/src/benchmarking.rs
index e19834f64ff73..7528293506aec 100644
--- a/frame/salary/src/benchmarking.rs
+++ b/frame/salary/src/benchmarking.rs
@@ -1,6 +1,6 @@
 // This file is part of Substrate.
 
-// Copyright (C) 2020-2022 Parity Technologies (UK) Ltd.
+// Copyright (C) Parity Technologies (UK) Ltd.
 // SPDX-License-Identifier: Apache-2.0
 
 // Licensed under the Apache License, Version 2.0 (the "License");
diff --git a/frame/society/src/benchmarking.rs b/frame/society/src/benchmarking.rs
index 1d6f44a1064da..f9cd378b97d3d 100644
--- a/frame/society/src/benchmarking.rs
+++ b/frame/society/src/benchmarking.rs
@@ -1,6 +1,6 @@
 // This file is part of Substrate.
 
-// Copyright (C) 2021-2022 Parity Technologies (UK) Ltd.
+// Copyright (C) Parity Technologies (UK) Ltd.
 // SPDX-License-Identifier: Apache-2.0
 
 // Licensed under the Apache License, Version 2.0 (the "License");
diff --git a/frame/society/src/migrations.rs b/frame/society/src/migrations.rs
index 0974de9a4a51b..e2cb178efcb16 100644
--- a/frame/society/src/migrations.rs
+++ b/frame/society/src/migrations.rs
@@ -1,6 +1,6 @@
 // This file is part of Substrate.
 
-// Copyright (C) 2020-2022 Parity Technologies (UK) Ltd.
+// Copyright (C) Parity Technologies (UK) Ltd.
 // SPDX-License-Identifier: Apache-2.0
 
 // Licensed under the Apache License, Version 2.0 (the "License");

From 3d3b43c1090d5054e3a670c8f115041f1d21d489 Mon Sep 17 00:00:00 2001
From: Gav <gavin@parity.io>
Date: Tue, 13 Jun 2023 19:35:37 +0100
Subject: [PATCH 35/43] Docs

---
 frame/society/src/weights.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/frame/society/src/weights.rs b/frame/society/src/weights.rs
index f72ef1c30f6cb..d113f617c886c 100644
--- a/frame/society/src/weights.rs
+++ b/frame/society/src/weights.rs
@@ -33,6 +33,7 @@
 // --execution=wasm
 // --wasm-execution=compiled
 // --template=./.maintain/frame-weight-template.hbs
+// --header=./HEADER-APACHE2
 // --output=./frame/society/src/weights.rs
 
 #![cfg_attr(rustfmt, rustfmt_skip)]

From 3b73c57e9c55783502d75b50818991d21d901857 Mon Sep 17 00:00:00 2001
From: Gav <gavin@parity.io>
Date: Tue, 13 Jun 2023 19:36:22 +0100
Subject: [PATCH 36/43] Remove accidental addition.

---
 primitives/core/src/bounded/bounded_vec.rs | 1315 --------------------
 1 file changed, 1315 deletions(-)
 delete mode 100644 primitives/core/src/bounded/bounded_vec.rs

diff --git a/primitives/core/src/bounded/bounded_vec.rs b/primitives/core/src/bounded/bounded_vec.rs
deleted file mode 100644
index 35fbacc2506b9..0000000000000
--- a/primitives/core/src/bounded/bounded_vec.rs
+++ /dev/null
@@ -1,1315 +0,0 @@
-// This file is part of Substrate.
-
-// Copyright (C) 2017-2022 Parity Technologies (UK) Ltd.
-// SPDX-License-Identifier: Apache-2.0
-
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 	http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//! Traits, types and structs to support putting a bounded vector into storage, as a raw value, map
-//! or a double map.
-
-use super::WeakBoundedVec;
-use crate::{Get, TryCollect};
-use codec::{Decode, Encode, EncodeLike, MaxEncodedLen};
-use core::{
-	ops::{Deref, Index, IndexMut, RangeBounds},
-	slice::SliceIndex,
-};
-#[cfg(feature = "std")]
-use serde::{
-	de::{Error, SeqAccess, Visitor},
-	Deserialize, Deserializer, Serialize,
-};
-use sp_std::{marker::PhantomData, prelude::*};
-
-/// A bounded vector.
-///
-/// It has implementations for efficient append and length decoding, as with a normal `Vec<_>`, once
-/// put into storage as a raw value, map or double-map.
-///
-/// As the name suggests, the length of the queue is always bounded. All internal operations ensure
-/// this bound is respected.
-#[cfg_attr(feature = "std", derive(Serialize), serde(transparent))]
-#[derive(Encode, scale_info::TypeInfo)]
-#[scale_info(skip_type_params(S))]
-pub struct BoundedVec<T, S>(
-	pub(super) Vec<T>,
-	#[cfg_attr(feature = "std", serde(skip_serializing))] PhantomData<S>,
-);
-
-/// Create an object through truncation.
-pub trait TruncateFrom<T> {
-	/// Create an object through truncation.
-	fn truncate_from(unbound: T) -> Self;
-}
-
-#[cfg(feature = "std")]
-impl<'de, T, S: Get<u32>> Deserialize<'de> for BoundedVec<T, S>
-where
-	T: Deserialize<'de>,
-{
-	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-	where
-		D: Deserializer<'de>,
-	{
-		struct VecVisitor<T, S: Get<u32>>(PhantomData<(T, S)>);
-
-		impl<'de, T, S: Get<u32>> Visitor<'de> for VecVisitor<T, S>
-		where
-			T: Deserialize<'de>,
-		{
-			type Value = Vec<T>;
-
-			fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-				formatter.write_str("a sequence")
-			}
-
-			fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-			where
-				A: SeqAccess<'de>,
-			{
-				let size = seq.size_hint().unwrap_or(0);
-				let max = match usize::try_from(S::get()) {
-					Ok(n) => n,
-					Err(_) => return Err(A::Error::custom("can't convert to usize")),
-				};
-				if size > max {
-					Err(A::Error::custom("out of bounds"))
-				} else {
-					let mut values = Vec::with_capacity(size);
-
-					while let Some(value) = seq.next_element()? {
-						values.push(value);
-						if values.len() > max {
-							return Err(A::Error::custom("out of bounds"))
-						}
-					}
-
-					Ok(values)
-				}
-			}
-		}
-
-		let visitor: VecVisitor<T, S> = VecVisitor(PhantomData);
-		deserializer
-			.deserialize_seq(visitor)
-			.map(|v| BoundedVec::<T, S>::try_from(v).map_err(|_| Error::custom("out of bounds")))?
-	}
-}
-
-/// A bounded slice.
-///
-/// Similar to a `BoundedVec`, but not owned and cannot be decoded.
-#[derive(Encode)]
-pub struct BoundedSlice<'a, T, S>(pub(super) &'a [T], PhantomData<S>);
-
-// This can be replaced with
-// #[derive(scale_info::TypeInfo)]
-// #[scale_info(skip_type_params(S))]
-// again once this issue is fixed in the rust compiler: https://github.com/rust-lang/rust/issues/96956
-// Tracking issues: https://github.com/paritytech/substrate/issues/11915
-impl<'a, T, S> scale_info::TypeInfo for BoundedSlice<'a, T, S>
-where
-	&'a [T]: scale_info::TypeInfo + 'static,
-	PhantomData<S>: scale_info::TypeInfo + 'static,
-	T: scale_info::TypeInfo + 'static,
-	S: 'static,
-{
-	type Identity = Self;
-
-	fn type_info() -> ::scale_info::Type {
-		scale_info::Type::builder()
-			.path(scale_info::Path::new("BoundedSlice", "sp_runtime::bounded::bounded_vec"))
-			.type_params(<[_]>::into_vec(Box::new([
-				scale_info::TypeParameter::new(
-					"T",
-					core::option::Option::Some(::scale_info::meta_type::<T>()),
-				),
-				scale_info::TypeParameter::new("S", ::core::option::Option::None),
-			])))
-			.docs(&[
-				"A bounded slice.",
-				"",
-				"Similar to a `BoundedVec`, but not owned and cannot be decoded.",
-			])
-			.composite(
-				scale_info::build::Fields::unnamed()
-					.field(|f| f.ty::<&'static [T]>().type_name("&'static[T]").docs(&[]))
-					.field(|f| f.ty::<PhantomData<S>>().type_name("PhantomData<S>").docs(&[])),
-			)
-	}
-}
-
-// `BoundedSlice`s encode to something which will always decode into a `BoundedVec`,
-// `WeakBoundedVec`, or a `Vec`.
-impl<'a, T: Encode + Decode, S: Get<u32>> EncodeLike<BoundedVec<T, S>> for BoundedSlice<'a, T, S> {}
-impl<'a, T: Encode + Decode, S: Get<u32>> EncodeLike<WeakBoundedVec<T, S>>
-	for BoundedSlice<'a, T, S>
-{
-}
-impl<'a, T: Encode + Decode, S: Get<u32>> EncodeLike<Vec<T>> for BoundedSlice<'a, T, S> {}
-
-impl<'a, T, BoundSelf, BoundRhs> PartialEq<BoundedSlice<'a, T, BoundRhs>>
-	for BoundedSlice<'a, T, BoundSelf>
-where
-	T: PartialEq,
-	BoundSelf: Get<u32>,
-	BoundRhs: Get<u32>,
-{
-	fn eq(&self, other: &BoundedSlice<'a, T, BoundRhs>) -> bool {
-		self.0 == other.0
-	}
-}
-
-impl<'a, T, BoundSelf, BoundRhs> PartialEq<BoundedVec<T, BoundRhs>>
-	for BoundedSlice<'a, T, BoundSelf>
-where
-	T: PartialEq,
-	BoundSelf: Get<u32>,
-	BoundRhs: Get<u32>,
-{
-	fn eq(&self, other: &BoundedVec<T, BoundRhs>) -> bool {
-		self.0 == other.0
-	}
-}
-
-impl<'a, T, BoundSelf, BoundRhs> PartialEq<WeakBoundedVec<T, BoundRhs>>
-	for BoundedSlice<'a, T, BoundSelf>
-where
-	T: PartialEq,
-	BoundSelf: Get<u32>,
-	BoundRhs: Get<u32>,
-{
-	fn eq(&self, other: &WeakBoundedVec<T, BoundRhs>) -> bool {
-		self.0 == other.0
-	}
-}
-
-impl<'a, T, S: Get<u32>> Eq for BoundedSlice<'a, T, S> where T: Eq {}
-
-impl<'a, T, BoundSelf, BoundRhs> PartialOrd<BoundedSlice<'a, T, BoundRhs>>
-	for BoundedSlice<'a, T, BoundSelf>
-where
-	T: PartialOrd,
-	BoundSelf: Get<u32>,
-	BoundRhs: Get<u32>,
-{
-	fn partial_cmp(&self, other: &BoundedSlice<'a, T, BoundRhs>) -> Option<sp_std::cmp::Ordering> {
-		self.0.partial_cmp(other.0)
-	}
-}
-
-impl<'a, T, BoundSelf, BoundRhs> PartialOrd<BoundedVec<T, BoundRhs>>
-	for BoundedSlice<'a, T, BoundSelf>
-where
-	T: PartialOrd,
-	BoundSelf: Get<u32>,
-	BoundRhs: Get<u32>,
-{
-	fn partial_cmp(&self, other: &BoundedVec<T, BoundRhs>) -> Option<sp_std::cmp::Ordering> {
-		self.0.partial_cmp(&*other.0)
-	}
-}
-
-impl<'a, T, BoundSelf, BoundRhs> PartialOrd<WeakBoundedVec<T, BoundRhs>>
-	for BoundedSlice<'a, T, BoundSelf>
-where
-	T: PartialOrd,
-	BoundSelf: Get<u32>,
-	BoundRhs: Get<u32>,
-{
-	fn partial_cmp(&self, other: &WeakBoundedVec<T, BoundRhs>) -> Option<sp_std::cmp::Ordering> {
-		self.0.partial_cmp(&*other.0)
-	}
-}
-
-impl<'a, T: Ord, Bound: Get<u32>> Ord for BoundedSlice<'a, T, Bound> {
-	fn cmp(&self, other: &Self) -> sp_std::cmp::Ordering {
-		self.0.cmp(&other.0)
-	}
-}
-
-impl<'a, T, S: Get<u32>> TryFrom<&'a [T]> for BoundedSlice<'a, T, S> {
-	type Error = &'a [T];
-	fn try_from(t: &'a [T]) -> Result<Self, Self::Error> {
-		if t.len() <= S::get() as usize {
-			Ok(BoundedSlice(t, PhantomData))
-		} else {
-			Err(t)
-		}
-	}
-}
-
-impl<'a, T, S> From<BoundedSlice<'a, T, S>> for &'a [T] {
-	fn from(t: BoundedSlice<'a, T, S>) -> Self {
-		t.0
-	}
-}
-
-impl<'a, T, S: Get<u32>> TruncateFrom<&'a [T]> for BoundedSlice<'a, T, S> {
-	fn truncate_from(unbound: &'a [T]) -> Self {
-		BoundedSlice::<T, S>::truncate_from(unbound)
-	}
-}
-
-impl<'a, T, S> Clone for BoundedSlice<'a, T, S> {
-	fn clone(&self) -> Self {
-		BoundedSlice(self.0, PhantomData)
-	}
-}
-
-impl<'a, T, S> sp_std::fmt::Debug for BoundedSlice<'a, T, S>
-where
-	&'a [T]: sp_std::fmt::Debug,
-	S: Get<u32>,
-{
-	fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result {
-		f.debug_tuple("BoundedSlice").field(&self.0).field(&S::get()).finish()
-	}
-}
-
-// Since a reference `&T` is always `Copy`, so is `BoundedSlice<'a, T, S>`.
-impl<'a, T, S> Copy for BoundedSlice<'a, T, S> {}
-
-// will allow for all immutable operations of `[T]` on `BoundedSlice<T>`.
-impl<'a, T, S> Deref for BoundedSlice<'a, T, S> {
-	type Target = [T];
-
-	fn deref(&self) -> &Self::Target {
-		self.0
-	}
-}
-
-impl<'a, T, S> sp_std::iter::IntoIterator for BoundedSlice<'a, T, S> {
-	type Item = &'a T;
-	type IntoIter = sp_std::slice::Iter<'a, T>;
-	fn into_iter(self) -> Self::IntoIter {
-		self.0.iter()
-	}
-}
-
-impl<'a, T, S: Get<u32>> BoundedSlice<'a, T, S> {
-	/// Create an instance from the first elements of the given slice (or all of it if it is smaller
-	/// than the length bound).
-	pub fn truncate_from(s: &'a [T]) -> Self {
-		Self(&s[0..(s.len().min(S::get() as usize))], PhantomData)
-	}
-}
-
-impl<T: Decode, S: Get<u32>> Decode for BoundedVec<T, S> {
-	fn decode<I: codec::Input>(input: &mut I) -> Result<Self, codec::Error> {
-		let inner = Vec::<T>::decode(input)?;
-		if inner.len() > S::get() as usize {
-			return Err("BoundedVec exceeds its limit".into())
-		}
-		Ok(Self(inner, PhantomData))
-	}
-
-	fn skip<I: codec::Input>(input: &mut I) -> Result<(), codec::Error> {
-		Vec::<T>::skip(input)
-	}
-}
-
-// `BoundedVec`s encode to something which will always decode as a `Vec`.
-impl<T: Encode + Decode, S: Get<u32>> EncodeLike<Vec<T>> for BoundedVec<T, S> {}
-
-impl<T, S> BoundedVec<T, S> {
-	/// Create `Self` with no items.
-	pub fn new() -> Self {
-		Self(Vec::new(), Default::default())
-	}
-
-	/// Create `Self` from `t` without any checks.
-	fn unchecked_from(t: Vec<T>) -> Self {
-		Self(t, Default::default())
-	}
-
-	/// Exactly the same semantics as `Vec::clear`.
-	pub fn clear(&mut self) {
-		self.0.clear()
-	}
-
-	/// Consume self, and return the inner `Vec`. Henceforth, the `Vec<_>` can be altered in an
-	/// arbitrary way. At some point, if the reverse conversion is required, `TryFrom<Vec<_>>` can
-	/// be used.
-	///
-	/// This is useful for cases if you need access to an internal API of the inner `Vec<_>` which
-	/// is not provided by the wrapper `BoundedVec`.
-	pub fn into_inner(self) -> Vec<T> {
-		self.0
-	}
-
-	/// Exactly the same semantics as [`slice::sort_by`].
-	///
-	/// This is safe since sorting cannot change the number of elements in the vector.
-	pub fn sort_by<F>(&mut self, compare: F)
-	where
-		F: FnMut(&T, &T) -> sp_std::cmp::Ordering,
-	{
-		self.0.sort_by(compare)
-	}
-
-	/// Exactly the same semantics as [`slice::sort_by_key`].
-	///
-	/// This is safe since sorting cannot change the number of elements in the vector.
-	pub fn sort_by_key<K, F>(&mut self, f: F)
-	where
-		F: FnMut(&T) -> K,
-		K: sp_std::cmp::Ord,
-	{
-		self.0.sort_by_key(f)
-	}
-
-	/// Exactly the same semantics as [`slice::sort`].
-	///
-	/// This is safe since sorting cannot change the number of elements in the vector.
-	pub fn sort(&mut self)
-	where
-		T: sp_std::cmp::Ord,
-	{
-		self.0.sort()
-	}
-
-	/// Exactly the same semantics as `Vec::remove`.
-	///
-	/// # Panics
-	///
-	/// Panics if `index` is out of bounds.
-	pub fn remove(&mut self, index: usize) -> T {
-		self.0.remove(index)
-	}
-
-	/// Exactly the same semantics as `slice::swap_remove`.
-	///
-	/// # Panics
-	///
-	/// Panics if `index` is out of bounds.
-	pub fn swap_remove(&mut self, index: usize) -> T {
-		self.0.swap_remove(index)
-	}
-
-	/// Exactly the same semantics as `Vec::retain`.
-	pub fn retain<F: FnMut(&T) -> bool>(&mut self, f: F) {
-		self.0.retain(f)
-	}
-
-	/// Exactly the same semantics as `slice::get_mut`.
-	pub fn get_mut<I: SliceIndex<[T]>>(
-		&mut self,
-		index: I,
-	) -> Option<&mut <I as SliceIndex<[T]>>::Output> {
-		self.0.get_mut(index)
-	}
-
-	/// Exactly the same semantics as `Vec::truncate`.
-	///
-	/// This is safe because `truncate` can never increase the length of the internal vector.
-	pub fn truncate(&mut self, s: usize) {
-		self.0.truncate(s);
-	}
-
-	/// Exactly the same semantics as `Vec::pop`.
-	///
-	/// This is safe since popping can only shrink the inner vector.
-	pub fn pop(&mut self) -> Option<T> {
-		self.0.pop()
-	}
-
-	/// Exactly the same semantics as [`slice::iter_mut`].
-	pub fn iter_mut(&mut self) -> core::slice::IterMut<'_, T> {
-		self.0.iter_mut()
-	}
-
-	/// Exactly the same semantics as [`slice::last_mut`].
-	pub fn last_mut(&mut self) -> Option<&mut T> {
-		self.0.last_mut()
-	}
-
-	/// Exact same semantics as [`Vec::drain`].
-	pub fn drain<R>(&mut self, range: R) -> sp_std::vec::Drain<'_, T>
-	where
-		R: RangeBounds<usize>,
-	{
-		self.0.drain(range)
-	}
-}
-
-impl<T, S: Get<u32>> From<BoundedVec<T, S>> for Vec<T> {
-	fn from(x: BoundedVec<T, S>) -> Vec<T> {
-		x.0
-	}
-}
-
-impl<T, S: Get<u32>> BoundedVec<T, S> {
-	/// Pre-allocate `capacity` items in self.
-	///
-	/// If `capacity` is greater than [`Self::bound`], then the minimum of the two is used.
-	pub fn with_bounded_capacity(capacity: usize) -> Self {
-		let capacity = capacity.min(Self::bound());
-		Self(Vec::with_capacity(capacity), Default::default())
-	}
-
-	/// Allocate self with the maximum possible capacity.
-	pub fn with_max_capacity() -> Self {
-		Self::with_bounded_capacity(Self::bound())
-	}
-
-	/// Consume and truncate the vector `v` in order to create a new instance of `Self` from it.
-	pub fn truncate_from(mut v: Vec<T>) -> Self {
-		v.truncate(Self::bound());
-		Self::unchecked_from(v)
-	}
-
-	/// Get the bound of the type in `usize`.
-	pub fn bound() -> usize {
-		S::get() as usize
-	}
-
-	/// Returns true of this collection is full.
-	pub fn is_full(&self) -> bool {
-		self.len() >= Self::bound()
-	}
-
-	/// Forces the insertion of `element` into `self` retaining all items with index at least
-	/// `index`.
-	///
-	/// If `index == 0` and `self.len() == Self::bound()`, then this is a no-op.
-	///
-	/// If `Self::bound() < index` or `self.len() < index`, then this is also a no-op.
-	///
-	/// Returns `Ok(maybe_removed)` if the item was inserted, where `maybe_removed` is
-	/// `Some(removed)` if an item was removed to make room for the new one. Returns `Err(())` if
-	/// `element` cannot be inserted.
-	pub fn force_insert_keep_right(
-		&mut self,
-		index: usize,
-		mut element: T,
-	) -> Result<Option<T>, ()> {
-		// Check against panics.
-		if Self::bound() < index || self.len() < index {
-			Err(())
-		} else if self.len() < Self::bound() {
-			// Cannot panic since self.len() >= index;
-			self.0.insert(index, element);
-			Ok(None)
-		} else {
-			if index == 0 {
-				return Err(())
-			}
-			sp_std::mem::swap(&mut self[0], &mut element);
-			// `[0..index] cannot panic since self.len() >= index.
-			// `rotate_left(1)` cannot panic because there is at least 1 element.
-			self[0..index].rotate_left(1);
-			Ok(Some(element))
-		}
-	}
-
-	/// Forces the insertion of `element` into `self` retaining all items with index at most
-	/// `index`.
-	///
-	/// If `index == Self::bound()` and `self.len() == Self::bound()`, then this is a no-op.
-	///
-	/// If `Self::bound() < index` or `self.len() < index`, then this is also a no-op.
-	///
-	/// Returns `Ok(maybe_removed)` if the item was inserted, where `maybe_removed` is
-	/// `Some(removed)` if an item was removed to make room for the new one. Returns `Err(element)`
-	/// if `element` cannot be inserted.
-	pub fn force_insert_keep_left(&mut self, index: usize, element: T) -> Result<Option<T>, T> {
-		// Check against panics.
-		if Self::bound() < index || self.len() < index || Self::bound() == 0 {
-			return Err(element)
-		}
-		// Noop condition.
-		if Self::bound() == index && self.len() <= Self::bound() {
-			return Err(element)
-		}
-		let maybe_removed = if self.is_full() {
-			// defensive-only: since we are at capacity, this is a noop.
-			self.0.truncate(Self::bound());
-			// if we truncate anything, it will be the last one.
-			self.0.pop()
-		} else {
-			None
-		};
-
-		// Cannot panic since `self.len() >= index`;
-		self.0.insert(index, element);
-		Ok(maybe_removed)
-	}
-
-	/// Move the position of an item from one location to another in the slice.
-	///
-	/// Except for the item being moved, the order of the slice remains the same.
-	///
-	/// - `index` is the location of the item to be moved.
-	/// - `insert_position` is the index of the item in the slice which should *immediately follow*
-	///   the item which is being moved.
-	///
-	/// Returns `true` of the operation was successful, otherwise `false` if a noop.
-	pub fn slide(&mut self, index: usize, insert_position: usize) -> bool {
-		// Check against panics.
-		if self.len() <= index || self.len() < insert_position || index == usize::MAX {
-			return false
-		}
-		// Noop conditions.
-		if index == insert_position || index + 1 == insert_position {
-			return false
-		}
-		if insert_position < index && index < self.len() {
-			// --- --- --- === === === === @@@ --- --- ---
-			//            ^-- N            ^O^
-			// ...
-			//               /-----<<<-----\
-			// --- --- --- === === === === @@@ --- --- ---
-			//               >>> >>> >>> >>>
-			// ...
-			// --- --- --- @@@ === === === === --- --- ---
-			//             ^N^
-			self[insert_position..index + 1].rotate_right(1);
-			return true
-		} else if insert_position > 0 && index + 1 < insert_position {
-			// Note that the apparent asymmetry of these two branches is due to the
-			// fact that the "new" position is the position to be inserted *before*.
-			// --- --- --- @@@ === === === === --- --- ---
-			//             ^O^                ^-- N
-			// ...
-			//               /----->>>-----\
-			// --- --- --- @@@ === === === === --- --- ---
-			//               <<< <<< <<< <<<
-			// ...
-			// --- --- --- === === === === @@@ --- --- ---
-			//                             ^N^
-			self[index..insert_position].rotate_left(1);
-			return true
-		}
-
-		debug_assert!(false, "all noop conditions should have been covered above");
-		false
-	}
-
-	/// Forces the insertion of `s` into `self` truncating first if necessary.
-	///
-	/// Infallible, but if the bound is zero, then it's a no-op.
-	pub fn force_push(&mut self, element: T) {
-		if Self::bound() > 0 {
-			self.0.truncate(Self::bound() as usize - 1);
-			self.0.push(element);
-		}
-	}
-
-	/// Same as `Vec::resize`, but if `size` is more than [`Self::bound`], then [`Self::bound`] is
-	/// used.
-	pub fn bounded_resize(&mut self, size: usize, value: T)
-	where
-		T: Clone,
-	{
-		let size = size.min(Self::bound());
-		self.0.resize(size, value);
-	}
-
-	/// Exactly the same semantics as [`Vec::extend`], but returns an error and does nothing if the
-	/// length of the outcome is larger than the bound.
-	pub fn try_extend(
-		&mut self,
-		with: impl IntoIterator<Item = T> + ExactSizeIterator,
-	) -> Result<(), ()> {
-		if with.len().saturating_add(self.len()) <= Self::bound() {
-			self.0.extend(with);
-			Ok(())
-		} else {
-			Err(())
-		}
-	}
-
-	/// Exactly the same semantics as [`Vec::append`], but returns an error and does nothing if the
-	/// length of the outcome is larger than the bound.
-	pub fn try_append(&mut self, other: &mut Vec<T>) -> Result<(), ()> {
-		if other.len().saturating_add(self.len()) <= Self::bound() {
-			self.0.append(other);
-			Ok(())
-		} else {
-			Err(())
-		}
-	}
-
-	/// Consumes self and mutates self via the given `mutate` function.
-	///
-	/// If the outcome of mutation is within bounds, `Some(Self)` is returned. Else, `None` is
-	/// returned.
-	///
-	/// This is essentially a *consuming* shorthand [`Self::into_inner`] -> `...` ->
-	/// [`Self::try_from`].
-	pub fn try_mutate(mut self, mut mutate: impl FnMut(&mut Vec<T>)) -> Option<Self> {
-		mutate(&mut self.0);
-		(self.0.len() <= Self::bound()).then(move || self)
-	}
-
-	/// Exactly the same semantics as [`Vec::insert`], but returns an `Err` (and is a noop) if the
-	/// new length of the vector exceeds `S`.
-	///
-	/// # Panics
-	///
-	/// Panics if `index > len`.
-	pub fn try_insert(&mut self, index: usize, element: T) -> Result<(), T> {
-		if self.len() < Self::bound() {
-			self.0.insert(index, element);
-			Ok(())
-		} else {
-			Err(element)
-		}
-	}
-
-	/// Exactly the same semantics as [`Vec::push`], but returns an `Err` (and is a noop) if the
-	/// new length of the vector exceeds `S`.
-	///
-	/// # Panics
-	///
-	/// Panics if the new capacity exceeds isize::MAX bytes.
-	pub fn try_push(&mut self, element: T) -> Result<(), T> {
-		if self.len() < Self::bound() {
-			self.0.push(element);
-			Ok(())
-		} else {
-			Err(element)
-		}
-	}
-}
-
-impl<T, S> BoundedVec<T, S> {
-	/// Return a [`BoundedSlice`] with the content and bound of [`Self`].
-	pub fn as_bounded_slice(&self) -> BoundedSlice<T, S> {
-		BoundedSlice(&self.0[..], PhantomData::default())
-	}
-}
-
-impl<T, S> Default for BoundedVec<T, S> {
-	fn default() -> Self {
-		// the bound cannot be below 0, which is satisfied by an empty vector
-		Self::unchecked_from(Vec::default())
-	}
-}
-
-impl<T, S> sp_std::fmt::Debug for BoundedVec<T, S>
-where
-	Vec<T>: sp_std::fmt::Debug,
-	S: Get<u32>,
-{
-	fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result {
-		f.debug_tuple("BoundedVec").field(&self.0).field(&Self::bound()).finish()
-	}
-}
-
-impl<T, S> Clone for BoundedVec<T, S>
-where
-	T: Clone,
-{
-	fn clone(&self) -> Self {
-		// bound is retained
-		Self::unchecked_from(self.0.clone())
-	}
-}
-
-impl<T, S: Get<u32>> TryFrom<Vec<T>> for BoundedVec<T, S> {
-	type Error = Vec<T>;
-	fn try_from(t: Vec<T>) -> Result<Self, Self::Error> {
-		if t.len() <= Self::bound() {
-			// explicit check just above
-			Ok(Self::unchecked_from(t))
-		} else {
-			Err(t)
-		}
-	}
-}
-
-impl<T, S: Get<u32>> TruncateFrom<Vec<T>> for BoundedVec<T, S> {
-	fn truncate_from(unbound: Vec<T>) -> Self {
-		BoundedVec::<T, S>::truncate_from(unbound)
-	}
-}
-
-// It is okay to give a non-mutable reference of the inner vec to anyone.
-impl<T, S> AsRef<Vec<T>> for BoundedVec<T, S> {
-	fn as_ref(&self) -> &Vec<T> {
-		&self.0
-	}
-}
-
-impl<T, S> AsRef<[T]> for BoundedVec<T, S> {
-	fn as_ref(&self) -> &[T] {
-		&self.0
-	}
-}
-
-impl<T, S> AsMut<[T]> for BoundedVec<T, S> {
-	fn as_mut(&mut self) -> &mut [T] {
-		&mut self.0
-	}
-}
-
-// will allow for all immutable operations of `Vec<T>` on `BoundedVec<T>`.
-impl<T, S> Deref for BoundedVec<T, S> {
-	type Target = Vec<T>;
-
-	fn deref(&self) -> &Self::Target {
-		&self.0
-	}
-}
-
-// Allows for indexing similar to a normal `Vec`. Can panic if out of bound.
-impl<T, S, I> Index<I> for BoundedVec<T, S>
-where
-	I: SliceIndex<[T]>,
-{
-	type Output = I::Output;
-
-	#[inline]
-	fn index(&self, index: I) -> &Self::Output {
-		self.0.index(index)
-	}
-}
-
-impl<T, S, I> IndexMut<I> for BoundedVec<T, S>
-where
-	I: SliceIndex<[T]>,
-{
-	#[inline]
-	fn index_mut(&mut self, index: I) -> &mut Self::Output {
-		self.0.index_mut(index)
-	}
-}
-
-impl<T, S> sp_std::iter::IntoIterator for BoundedVec<T, S> {
-	type Item = T;
-	type IntoIter = sp_std::vec::IntoIter<T>;
-	fn into_iter(self) -> Self::IntoIter {
-		self.0.into_iter()
-	}
-}
-
-impl<'a, T, S> sp_std::iter::IntoIterator for &'a BoundedVec<T, S> {
-	type Item = &'a T;
-	type IntoIter = sp_std::slice::Iter<'a, T>;
-	fn into_iter(self) -> Self::IntoIter {
-		self.0.iter()
-	}
-}
-
-impl<'a, T, S> sp_std::iter::IntoIterator for &'a mut BoundedVec<T, S> {
-	type Item = &'a mut T;
-	type IntoIter = sp_std::slice::IterMut<'a, T>;
-	fn into_iter(self) -> Self::IntoIter {
-		self.0.iter_mut()
-	}
-}
-
-impl<T, S> codec::DecodeLength for BoundedVec<T, S> {
-	fn len(self_encoded: &[u8]) -> Result<usize, codec::Error> {
-		// `BoundedVec<T, _>` stored just a `Vec<T>`, thus the length is at the beginning in
-		// `Compact` form, and same implementation as `Vec<T>` can be used.
-		<Vec<T> as codec::DecodeLength>::len(self_encoded)
-	}
-}
-
-impl<T, BoundSelf, BoundRhs> PartialEq<BoundedVec<T, BoundRhs>> for BoundedVec<T, BoundSelf>
-where
-	T: PartialEq,
-	BoundSelf: Get<u32>,
-	BoundRhs: Get<u32>,
-{
-	fn eq(&self, rhs: &BoundedVec<T, BoundRhs>) -> bool {
-		self.0 == rhs.0
-	}
-}
-
-impl<T, BoundSelf, BoundRhs> PartialEq<WeakBoundedVec<T, BoundRhs>> for BoundedVec<T, BoundSelf>
-where
-	T: PartialEq,
-	BoundSelf: Get<u32>,
-	BoundRhs: Get<u32>,
-{
-	fn eq(&self, rhs: &WeakBoundedVec<T, BoundRhs>) -> bool {
-		self.0 == rhs.0
-	}
-}
-
-impl<'a, T, BoundSelf, BoundRhs> PartialEq<BoundedSlice<'a, T, BoundRhs>>
-	for BoundedVec<T, BoundSelf>
-where
-	T: PartialEq,
-	BoundSelf: Get<u32>,
-	BoundRhs: Get<u32>,
-{
-	fn eq(&self, rhs: &BoundedSlice<'a, T, BoundRhs>) -> bool {
-		self.0 == rhs.0
-	}
-}
-
-impl<'a, T: PartialEq, S: Get<u32>> PartialEq<&'a [T]> for BoundedSlice<'a, T, S> {
-	fn eq(&self, other: &&'a [T]) -> bool {
-		&self.0 == other
-	}
-}
-
-impl<T: PartialEq, S: Get<u32>> PartialEq<Vec<T>> for BoundedVec<T, S> {
-	fn eq(&self, other: &Vec<T>) -> bool {
-		&self.0 == other
-	}
-}
-
-impl<T, S: Get<u32>> Eq for BoundedVec<T, S> where T: Eq {}
-
-impl<T, BoundSelf, BoundRhs> PartialOrd<BoundedVec<T, BoundRhs>> for BoundedVec<T, BoundSelf>
-where
-	T: PartialOrd,
-	BoundSelf: Get<u32>,
-	BoundRhs: Get<u32>,
-{
-	fn partial_cmp(&self, other: &BoundedVec<T, BoundRhs>) -> Option<sp_std::cmp::Ordering> {
-		self.0.partial_cmp(&other.0)
-	}
-}
-
-impl<T, BoundSelf, BoundRhs> PartialOrd<WeakBoundedVec<T, BoundRhs>> for BoundedVec<T, BoundSelf>
-where
-	T: PartialOrd,
-	BoundSelf: Get<u32>,
-	BoundRhs: Get<u32>,
-{
-	fn partial_cmp(&self, other: &WeakBoundedVec<T, BoundRhs>) -> Option<sp_std::cmp::Ordering> {
-		self.0.partial_cmp(&other.0)
-	}
-}
-
-impl<'a, T, BoundSelf, BoundRhs> PartialOrd<BoundedSlice<'a, T, BoundRhs>>
-	for BoundedVec<T, BoundSelf>
-where
-	T: PartialOrd,
-	BoundSelf: Get<u32>,
-	BoundRhs: Get<u32>,
-{
-	fn partial_cmp(&self, other: &BoundedSlice<'a, T, BoundRhs>) -> Option<sp_std::cmp::Ordering> {
-		(&*self.0).partial_cmp(other.0)
-	}
-}
-
-impl<T: Ord, Bound: Get<u32>> Ord for BoundedVec<T, Bound> {
-	fn cmp(&self, other: &Self) -> sp_std::cmp::Ordering {
-		self.0.cmp(&other.0)
-	}
-}
-
-impl<T, S> MaxEncodedLen for BoundedVec<T, S>
-where
-	T: MaxEncodedLen,
-	S: Get<u32>,
-	BoundedVec<T, S>: Encode,
-{
-	fn max_encoded_len() -> usize {
-		// BoundedVec<T, S> encodes like Vec<T> which encodes like [T], which is a compact u32
-		// plus each item in the slice:
-		// See: https://docs.substrate.io/reference/scale-codec/
-		codec::Compact(S::get())
-			.encoded_size()
-			.saturating_add(Self::bound().saturating_mul(T::max_encoded_len()))
-	}
-}
-
-impl<I, T, Bound> TryCollect<BoundedVec<T, Bound>> for I
-where
-	I: ExactSizeIterator + Iterator<Item = T>,
-	Bound: Get<u32>,
-{
-	type Error = &'static str;
-
-	fn try_collect(self) -> Result<BoundedVec<T, Bound>, Self::Error> {
-		if self.len() > Bound::get() as usize {
-			Err("iterator length too big")
-		} else {
-			Ok(BoundedVec::<T, Bound>::unchecked_from(self.collect::<Vec<T>>()))
-		}
-	}
-}
-
-#[cfg(test)]
-pub mod test {
-	use super::*;
-	use crate::{bounded_vec, ConstU32};
-
-	#[test]
-	fn slice_truncate_from_works() {
-		let bounded = BoundedSlice::<u32, ConstU32<4>>::truncate_from(&[1, 2, 3, 4, 5]);
-		assert_eq!(bounded.deref(), &[1, 2, 3, 4]);
-		let bounded = BoundedSlice::<u32, ConstU32<4>>::truncate_from(&[1, 2, 3, 4]);
-		assert_eq!(bounded.deref(), &[1, 2, 3, 4]);
-		let bounded = BoundedSlice::<u32, ConstU32<4>>::truncate_from(&[1, 2, 3]);
-		assert_eq!(bounded.deref(), &[1, 2, 3]);
-	}
-
-	#[test]
-	fn slide_works() {
-		let mut b: BoundedVec<u32, ConstU32<6>> = bounded_vec![0, 1, 2, 3, 4, 5];
-		assert!(b.slide(1, 5));
-		assert_eq!(*b, vec![0, 2, 3, 4, 1, 5]);
-		assert!(b.slide(4, 0));
-		assert_eq!(*b, vec![1, 0, 2, 3, 4, 5]);
-		assert!(b.slide(0, 2));
-		assert_eq!(*b, vec![0, 1, 2, 3, 4, 5]);
-		assert!(b.slide(1, 6));
-		assert_eq!(*b, vec![0, 2, 3, 4, 5, 1]);
-		assert!(b.slide(0, 6));
-		assert_eq!(*b, vec![2, 3, 4, 5, 1, 0]);
-		assert!(b.slide(5, 0));
-		assert_eq!(*b, vec![0, 2, 3, 4, 5, 1]);
-		assert!(!b.slide(6, 0));
-		assert!(!b.slide(7, 0));
-		assert_eq!(*b, vec![0, 2, 3, 4, 5, 1]);
-
-		let mut c: BoundedVec<u32, ConstU32<6>> = bounded_vec![0, 1, 2];
-		assert!(!c.slide(1, 5));
-		assert_eq!(*c, vec![0, 1, 2]);
-		assert!(!c.slide(4, 0));
-		assert_eq!(*c, vec![0, 1, 2]);
-		assert!(!c.slide(3, 0));
-		assert_eq!(*c, vec![0, 1, 2]);
-		assert!(c.slide(2, 0));
-		assert_eq!(*c, vec![2, 0, 1]);
-	}
-
-	#[test]
-	fn slide_noops_work() {
-		let mut b: BoundedVec<u32, ConstU32<6>> = bounded_vec![0, 1, 2, 3, 4, 5];
-		assert!(!b.slide(3, 3));
-		assert_eq!(*b, vec![0, 1, 2, 3, 4, 5]);
-		assert!(!b.slide(3, 4));
-		assert_eq!(*b, vec![0, 1, 2, 3, 4, 5]);
-	}
-
-	#[test]
-	fn force_insert_keep_left_works() {
-		let mut b: BoundedVec<u32, ConstU32<4>> = bounded_vec![];
-		assert_eq!(b.force_insert_keep_left(1, 10), Err(()));
-		assert!(b.is_empty());
-
-		assert_eq!(b.force_insert_keep_left(0, 30), Ok(None));
-		assert_eq!(b.force_insert_keep_left(0, 10), Ok(None));
-		assert_eq!(b.force_insert_keep_left(1, 20), Ok(None));
-		assert_eq!(b.force_insert_keep_left(3, 40), Ok(None));
-		assert_eq!(*b, vec![10, 20, 30, 40]);
-		// at capacity.
-		assert_eq!(b.force_insert_keep_left(4, 41), Err(()));
-		assert_eq!(*b, vec![10, 20, 30, 40]);
-		assert_eq!(b.force_insert_keep_left(3, 31), Ok(Some(40)));
-		assert_eq!(*b, vec![10, 20, 30, 31]);
-		assert_eq!(b.force_insert_keep_left(1, 11), Ok(Some(31)));
-		assert_eq!(*b, vec![10, 11, 20, 30]);
-		assert_eq!(b.force_insert_keep_left(0, 1), Ok(Some(30)));
-		assert_eq!(*b, vec![1, 10, 11, 20]);
-
-		let mut z: BoundedVec<u32, ConstU32<0>> = bounded_vec![];
-		assert!(z.is_empty());
-		assert_eq!(z.force_insert_keep_left(0, 10), Err(()));
-		assert!(z.is_empty());
-	}
-
-	#[test]
-	fn force_insert_keep_right_works() {
-		let mut b: BoundedVec<u32, ConstU32<4>> = bounded_vec![];
-		assert_eq!(b.force_insert_keep_right(1, 10), Err(()));
-		assert!(b.is_empty());
-
-		assert_eq!(b.force_insert_keep_right(0, 30), Ok(None));
-		assert_eq!(b.force_insert_keep_right(0, 10), Ok(None));
-		assert_eq!(b.force_insert_keep_right(1, 20), Ok(None));
-		assert_eq!(b.force_insert_keep_right(3, 40), Ok(None));
-		assert_eq!(*b, vec![10, 20, 30, 40]);
-
-		// at capacity.
-		assert_eq!(b.force_insert_keep_right(0, 0), Err(()));
-		assert_eq!(*b, vec![10, 20, 30, 40]);
-		assert_eq!(b.force_insert_keep_right(1, 11), Ok(Some(10)));
-		assert_eq!(*b, vec![11, 20, 30, 40]);
-		assert_eq!(b.force_insert_keep_right(3, 31), Ok(Some(11)));
-		assert_eq!(*b, vec![20, 30, 31, 40]);
-		assert_eq!(b.force_insert_keep_right(4, 41), Ok(Some(20)));
-		assert_eq!(*b, vec![30, 31, 40, 41]);
-
-		assert_eq!(b.force_insert_keep_right(5, 69), Err(()));
-		assert_eq!(*b, vec![30, 31, 40, 41]);
-
-		let mut z: BoundedVec<u32, ConstU32<0>> = bounded_vec![];
-		assert!(z.is_empty());
-		assert_eq!(z.force_insert_keep_right(0, 10), Err(()));
-		assert!(z.is_empty());
-	}
-
-	#[test]
-	fn bound_returns_correct_value() {
-		assert_eq!(BoundedVec::<u32, ConstU32<7>>::bound(), 7);
-	}
-
-	#[test]
-	fn try_insert_works() {
-		let mut bounded: BoundedVec<u32, ConstU32<4>> = bounded_vec![1, 2, 3];
-		bounded.try_insert(1, 0).unwrap();
-		assert_eq!(*bounded, vec![1, 0, 2, 3]);
-
-		assert!(bounded.try_insert(0, 9).is_err());
-		assert_eq!(*bounded, vec![1, 0, 2, 3]);
-	}
-
-	#[test]
-	fn constructor_macro_works() {
-		// With values. Use some brackets to make sure the macro doesn't expand.
-		let bv: BoundedVec<(u32, u32), ConstU32<3>> = bounded_vec![(1, 2), (1, 2), (1, 2)];
-		assert_eq!(bv, vec![(1, 2), (1, 2), (1, 2)]);
-
-		// With repetition.
-		let bv: BoundedVec<(u32, u32), ConstU32<3>> = bounded_vec![(1, 2); 3];
-		assert_eq!(bv, vec![(1, 2), (1, 2), (1, 2)]);
-	}
-
-	#[test]
-	#[should_panic(expected = "insertion index (is 9) should be <= len (is 3)")]
-	fn try_inert_panics_if_oob() {
-		let mut bounded: BoundedVec<u32, ConstU32<4>> = bounded_vec![1, 2, 3];
-		bounded.try_insert(9, 0).unwrap();
-	}
-
-	#[test]
-	fn try_push_works() {
-		let mut bounded: BoundedVec<u32, ConstU32<4>> = bounded_vec![1, 2, 3];
-		bounded.try_push(0).unwrap();
-		assert_eq!(*bounded, vec![1, 2, 3, 0]);
-
-		assert!(bounded.try_push(9).is_err());
-	}
-
-	#[test]
-	fn deref_vec_coercion_works() {
-		let bounded: BoundedVec<u32, ConstU32<7>> = bounded_vec![1, 2, 3];
-		// these methods come from deref-ed vec.
-		assert_eq!(bounded.len(), 3);
-		assert!(bounded.iter().next().is_some());
-		assert!(!bounded.is_empty());
-	}
-
-	#[test]
-	fn deref_slice_coercion_works() {
-		let bounded = BoundedSlice::<u32, ConstU32<7>>::try_from(&[1, 2, 3][..]).unwrap();
-		// these methods come from deref-ed slice.
-		assert_eq!(bounded.len(), 3);
-		assert!(bounded.iter().next().is_some());
-		assert!(!bounded.is_empty());
-	}
-
-	#[test]
-	fn try_mutate_works() {
-		let bounded: BoundedVec<u32, ConstU32<7>> = bounded_vec![1, 2, 3, 4, 5, 6];
-		let bounded = bounded.try_mutate(|v| v.push(7)).unwrap();
-		assert_eq!(bounded.len(), 7);
-		assert!(bounded.try_mutate(|v| v.push(8)).is_none());
-	}
-
-	#[test]
-	fn slice_indexing_works() {
-		let bounded: BoundedVec<u32, ConstU32<7>> = bounded_vec![1, 2, 3, 4, 5, 6];
-		assert_eq!(&bounded[0..=2], &[1, 2, 3]);
-	}
-
-	#[test]
-	fn vec_eq_works() {
-		let bounded: BoundedVec<u32, ConstU32<7>> = bounded_vec![1, 2, 3, 4, 5, 6];
-		assert_eq!(bounded, vec![1, 2, 3, 4, 5, 6]);
-	}
-
-	#[test]
-	fn too_big_vec_fail_to_decode() {
-		let v: Vec<u32> = vec![1, 2, 3, 4, 5];
-		assert_eq!(
-			BoundedVec::<u32, ConstU32<4>>::decode(&mut &v.encode()[..]),
-			Err("BoundedVec exceeds its limit".into()),
-		);
-	}
-
-	#[test]
-	fn eq_works() {
-		// of same type
-		let b1: BoundedVec<u32, ConstU32<7>> = bounded_vec![1, 2, 3];
-		let b2: BoundedVec<u32, ConstU32<7>> = bounded_vec![1, 2, 3];
-		assert_eq!(b1, b2);
-
-		// of different type, but same value and bound.
-		crate::parameter_types! {
-			B1: u32 = 7;
-			B2: u32 = 7;
-		}
-		let b1: BoundedVec<u32, B1> = bounded_vec![1, 2, 3];
-		let b2: BoundedVec<u32, B2> = bounded_vec![1, 2, 3];
-		assert_eq!(b1, b2);
-	}
-
-	#[test]
-	fn ord_works() {
-		use std::cmp::Ordering;
-		let b1: BoundedVec<u32, ConstU32<7>> = bounded_vec![1, 2, 3];
-		let b2: BoundedVec<u32, ConstU32<7>> = bounded_vec![1, 3, 2];
-
-		// ordering for vec is lexicographic.
-		assert_eq!(b1.cmp(&b2), Ordering::Less);
-		assert_eq!(b1.cmp(&b2), b1.into_inner().cmp(&b2.into_inner()));
-	}
-
-	#[test]
-	fn try_extend_works() {
-		let mut b: BoundedVec<u32, ConstU32<5>> = bounded_vec![1, 2, 3];
-
-		assert!(b.try_extend(vec![4].into_iter()).is_ok());
-		assert_eq!(*b, vec![1, 2, 3, 4]);
-
-		assert!(b.try_extend(vec![5].into_iter()).is_ok());
-		assert_eq!(*b, vec![1, 2, 3, 4, 5]);
-
-		assert!(b.try_extend(vec![6].into_iter()).is_err());
-		assert_eq!(*b, vec![1, 2, 3, 4, 5]);
-
-		let mut b: BoundedVec<u32, ConstU32<5>> = bounded_vec![1, 2, 3];
-		assert!(b.try_extend(vec![4, 5].into_iter()).is_ok());
-		assert_eq!(*b, vec![1, 2, 3, 4, 5]);
-
-		let mut b: BoundedVec<u32, ConstU32<5>> = bounded_vec![1, 2, 3];
-		assert!(b.try_extend(vec![4, 5, 6].into_iter()).is_err());
-		assert_eq!(*b, vec![1, 2, 3]);
-	}
-
-	#[test]
-	fn test_serializer() {
-		let c: BoundedVec<u32, ConstU32<6>> = bounded_vec![0, 1, 2];
-		assert_eq!(serde_json::json!(&c).to_string(), r#"[0,1,2]"#);
-	}
-
-	#[test]
-	fn test_deserializer() {
-		let c: BoundedVec<u32, ConstU32<6>> = serde_json::from_str(r#"[0,1,2]"#).unwrap();
-
-		assert_eq!(c.len(), 3);
-		assert_eq!(c[0], 0);
-		assert_eq!(c[1], 1);
-		assert_eq!(c[2], 2);
-	}
-
-	#[test]
-	fn test_deserializer_failed() {
-		let c: Result<BoundedVec<u32, ConstU32<4>>, serde_json::error::Error> =
-			serde_json::from_str(r#"[0,1,2,3,4,5]"#);
-
-		match c {
-			Err(msg) => assert_eq!(msg.to_string(), "out of bounds at line 1 column 11"),
-			_ => unreachable!("deserializer must raise error"),
-		}
-	}
-
-	#[test]
-	fn bounded_vec_try_from_works() {
-		assert!(BoundedVec::<u32, ConstU32<2>>::try_from(vec![0]).is_ok());
-		assert!(BoundedVec::<u32, ConstU32<2>>::try_from(vec![0, 1]).is_ok());
-		assert!(BoundedVec::<u32, ConstU32<2>>::try_from(vec![0, 1, 2]).is_err());
-	}
-
-	#[test]
-	fn bounded_slice_try_from_works() {
-		assert!(BoundedSlice::<u32, ConstU32<2>>::try_from(&[0][..]).is_ok());
-		assert!(BoundedSlice::<u32, ConstU32<2>>::try_from(&[0, 1][..]).is_ok());
-		assert!(BoundedSlice::<u32, ConstU32<2>>::try_from(&[0, 1, 2][..]).is_err());
-	}
-
-	#[test]
-	fn can_be_collected() {
-		let b1: BoundedVec<u32, ConstU32<5>> = bounded_vec![1, 2, 3, 4];
-		let b2: BoundedVec<u32, ConstU32<5>> = b1.iter().map(|x| x + 1).try_collect().unwrap();
-		assert_eq!(b2, vec![2, 3, 4, 5]);
-
-		// can also be collected into a collection of length 4.
-		let b2: BoundedVec<u32, ConstU32<4>> = b1.iter().map(|x| x + 1).try_collect().unwrap();
-		assert_eq!(b2, vec![2, 3, 4, 5]);
-
-		// can be mutated further into iterators that are `ExactSizedIterator`.
-		let b2: BoundedVec<u32, ConstU32<4>> =
-			b1.iter().map(|x| x + 1).rev().try_collect().unwrap();
-		assert_eq!(b2, vec![5, 4, 3, 2]);
-
-		let b2: BoundedVec<u32, ConstU32<4>> =
-			b1.iter().map(|x| x + 1).rev().skip(2).try_collect().unwrap();
-		assert_eq!(b2, vec![3, 2]);
-		let b2: BoundedVec<u32, ConstU32<2>> =
-			b1.iter().map(|x| x + 1).rev().skip(2).try_collect().unwrap();
-		assert_eq!(b2, vec![3, 2]);
-
-		let b2: BoundedVec<u32, ConstU32<4>> =
-			b1.iter().map(|x| x + 1).rev().take(2).try_collect().unwrap();
-		assert_eq!(b2, vec![5, 4]);
-		let b2: BoundedVec<u32, ConstU32<2>> =
-			b1.iter().map(|x| x + 1).rev().take(2).try_collect().unwrap();
-		assert_eq!(b2, vec![5, 4]);
-
-		// but these worn't work
-		let b2: Result<BoundedVec<u32, ConstU32<3>>, _> = b1.iter().map(|x| x + 1).try_collect();
-		assert!(b2.is_err());
-
-		let b2: Result<BoundedVec<u32, ConstU32<1>>, _> =
-			b1.iter().map(|x| x + 1).rev().take(2).try_collect();
-		assert!(b2.is_err());
-	}
-
-	#[test]
-	fn bounded_vec_debug_works() {
-		let bound = BoundedVec::<u32, ConstU32<5>>::truncate_from(vec![1, 2, 3]);
-		assert_eq!(format!("{:?}", bound), "BoundedVec([1, 2, 3], 5)");
-	}
-
-	#[test]
-	fn bounded_slice_debug_works() {
-		let bound = BoundedSlice::<u32, ConstU32<5>>::truncate_from(&[1, 2, 3]);
-		assert_eq!(format!("{:?}", bound), "BoundedSlice([1, 2, 3], 5)");
-	}
-
-	#[test]
-	fn bounded_vec_sort_by_key_works() {
-		let mut v: BoundedVec<i32, ConstU32<5>> = bounded_vec![-5, 4, 1, -3, 2];
-		// Sort by absolute value.
-		v.sort_by_key(|k| k.abs());
-		assert_eq!(v, vec![1, 2, -3, 4, -5]);
-	}
-
-	#[test]
-	fn bounded_vec_truncate_from_works() {
-		let unbound = vec![1, 2, 3, 4, 5];
-		let bound = BoundedVec::<u32, ConstU32<3>>::truncate_from(unbound.clone());
-		assert_eq!(bound, vec![1, 2, 3]);
-	}
-
-	#[test]
-	fn bounded_slice_truncate_from_works() {
-		let unbound = [1, 2, 3, 4, 5];
-		let bound = BoundedSlice::<u32, ConstU32<3>>::truncate_from(&unbound);
-		assert_eq!(bound, &[1, 2, 3][..]);
-	}
-
-	#[test]
-	fn bounded_slice_partialeq_slice_works() {
-		let unbound = [1, 2, 3];
-		let bound = BoundedSlice::<u32, ConstU32<3>>::truncate_from(&unbound);
-
-		assert_eq!(bound, &unbound[..]);
-		assert!(bound == &unbound[..]);
-	}
-}

From e51eebf57b15953c3142eaf6f5bb18799fd89f8d Mon Sep 17 00:00:00 2001
From: Gav <gavin@parity.io>
Date: Tue, 13 Jun 2023 20:00:50 +0100
Subject: [PATCH 37/43] Fixes

---
 primitives/state-machine/src/overlayed_changes/changeset.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/primitives/state-machine/src/overlayed_changes/changeset.rs b/primitives/state-machine/src/overlayed_changes/changeset.rs
index 9d8579e7f2876..8f2d02fd6840e 100644
--- a/primitives/state-machine/src/overlayed_changes/changeset.rs
+++ b/primitives/state-machine/src/overlayed_changes/changeset.rs
@@ -442,7 +442,6 @@ impl OverlayedChangeSet {
 				count += 1;
 			}
 			val.set(None, insert_dirty(&mut self.dirty_keys, key.clone()), at_extrinsic);
-			count += 1;
 		}
 		count
 	}

From 43ea1dbede5a4eb0d90a40ba59daa2023fe58529 Mon Sep 17 00:00:00 2001
From: Gav <gavin@parity.io>
Date: Wed, 14 Jun 2023 09:56:17 +0100
Subject: [PATCH 38/43] Clippy

---
 frame/society/src/lib.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index 48ab159f7cbf7..828ca59142dbc 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -840,7 +840,7 @@ pub mod pallet {
 			let deposit = params.candidate_deposit;
 			// NOTE: Reserve must happen before `insert_bid` since that could end up unreserving.
 			T::Currency::reserve(&who, deposit)?;
-			Self::insert_bid(&mut bids, &who, value.clone(), BidKind::Deposit(deposit));
+			Self::insert_bid(&mut bids, &who, value, BidKind::Deposit(deposit));
 
 			Bids::<T, I>::put(bids);
 			Self::deposit_event(Event::<T, I>::Bid { candidate_id: who, offer: value });
@@ -917,7 +917,7 @@ pub mod pallet {
 			// Update voucher record.
 			record.vouching = Some(VouchingStatus::Vouching);
 			// Update bids
-			Self::insert_bid(&mut bids, &who, value.clone(), BidKind::Vouch(voucher.clone(), tip));
+			Self::insert_bid(&mut bids, &who, value, BidKind::Vouch(voucher.clone(), tip));
 
 			// Write new state.
 			Members::<T, I>::insert(&voucher, &record);
@@ -1450,7 +1450,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		let voting_period = T::VotingPeriod::get();
 		let rotation_period = voting_period + claim_period;
 		let now = frame_system::Pallet::<T>::block_number();
-		let phase = now % rotation_period.clone();
+		let phase = now % rotation_period;
 		if phase < voting_period {
 			Period::Voting { elapsed: phase, more: voting_period - phase }
 		} else {

From bfed684129bfe86507d86527703cd47a3f66643b Mon Sep 17 00:00:00 2001
From: Gav <gavin@parity.io>
Date: Wed, 14 Jun 2023 10:43:46 +0100
Subject: [PATCH 39/43] Fixes

---
 frame/society/src/migrations.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/frame/society/src/migrations.rs b/frame/society/src/migrations.rs
index e2cb178efcb16..32db4d35e46d9 100644
--- a/frame/society/src/migrations.rs
+++ b/frame/society/src/migrations.rs
@@ -40,7 +40,7 @@ impl<
 	#[cfg(feature = "try-runtime")]
 	fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
 		assert!(
-			can_migrate(),
+			can_migrate::<T, I>(),
 			"Invalid (perhaps already-migrated) state detected prior to migration"
 		);
 		Ok(Vec::new())

From ba534a6123a884c2901bf99f5ae9d49a8b92c78e Mon Sep 17 00:00:00 2001
From: Gav <gavin@parity.io>
Date: Wed, 14 Jun 2023 14:15:19 +0100
Subject: [PATCH 40/43] Docs

---
 frame/society/src/lib.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index 828ca59142dbc..930f29eeaa094 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -1004,7 +1004,6 @@ pub mod pallet {
 		///
 		/// Key: M (len of members)
 		/// Total Complexity: O(M + logM)
-		/// # </weight>
 		#[pallet::call_index(5)]
 		#[pallet::weight(T::WeightInfo::defender_vote())]
 		pub fn defender_vote(origin: OriginFor<T>, approve: bool) -> DispatchResultWithPostInfo {

From 1528a58b103bffb14de90d7eb7b055123dfe1052 Mon Sep 17 00:00:00 2001
From: Gav <gavin@parity.io>
Date: Thu, 15 Jun 2023 11:43:59 +0100
Subject: [PATCH 41/43] Improve try_runtime test

---
 frame/society/src/lib.rs        | 39 ---------------------------------
 frame/society/src/migrations.rs | 29 ++++++++++++++++++------
 2 files changed, 22 insertions(+), 46 deletions(-)

diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index 930f29eeaa094..b4b3aecce71c1 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -465,17 +465,6 @@ pub struct GroupParams<Balance> {
 
 pub type GroupParamsFor<T, I> = GroupParams<BalanceOf<T, I>>;
 
-/// A vote by a member on a candidate application.
-#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
-pub enum OldVote {
-	/// The member has been chosen to be skeptic and has not yet taken any action.
-	Skeptic,
-	/// The member has rejected the candidate's application.
-	Reject,
-	/// The member approves of the candidate's application.
-	Approve,
-}
-
 #[frame_support::pallet]
 pub mod pallet {
 	use super::*;
@@ -822,9 +811,6 @@ pub mod pallet {
 		///
 		/// Parameters:
 		/// - `value`: A one time payment the bid would like to receive when joining the society.
-		///
-		/// Key: B (len of bids), C (len of candidates), M (len of members), X (balance reserve)
-		/// Total Complexity: O(M + B + C + logM + logB + X)
 		#[pallet::call_index(0)]
 		#[pallet::weight(T::WeightInfo::bid())]
 		pub fn bid(origin: OriginFor<T>, value: BalanceOf<T, I>) -> DispatchResult {
@@ -854,9 +840,6 @@ pub mod pallet {
 		/// Payment: The bid deposit is unreserved if the user made a bid.
 		///
 		/// The dispatch origin for this call must be _Signed_ and a bidder.
-		///
-		/// Key: B (len of bids), X (balance unreserve)
-		/// Total Complexity: O(B + X)
 		#[pallet::call_index(1)]
 		#[pallet::weight(T::WeightInfo::unbid())]
 		pub fn unbid(origin: OriginFor<T>) -> DispatchResult {
@@ -887,9 +870,6 @@ pub mod pallet {
 		/// a member in the society.
 		/// - `tip`: Your cut of the total `value` payout when the candidate is inducted into
 		/// the society. Tips larger than `value` will be saturated upon payout.
-		///
-		/// Key: B (len of bids), C (len of candidates), M (len of members)
-		/// Total Complexity: O(M + B + C + logM + logB + X)
 		#[pallet::call_index(2)]
 		#[pallet::weight(T::WeightInfo::vouch())]
 		pub fn vouch(
@@ -937,9 +917,6 @@ pub mod pallet {
 		///
 		/// Parameters:
 		/// - `pos`: Position in the `Bids` vector of the bid who should be unvouched.
-		///
-		/// Key: B (len of bids)
-		/// Total Complexity: O(B)
 		#[pallet::call_index(3)]
 		#[pallet::weight(T::WeightInfo::unvouch())]
 		pub fn unvouch(origin: OriginFor<T>) -> DispatchResult {
@@ -966,9 +943,6 @@ pub mod pallet {
 		/// - `candidate`: The candidate that the member would like to bid on.
 		/// - `approve`: A boolean which says if the candidate should be approved (`true`) or
 		///   rejected (`false`).
-		///
-		/// Key: C (len of candidates), M (len of members)
-		/// Total Complexity: O(M + logM + C)
 		#[pallet::call_index(4)]
 		#[pallet::weight(T::WeightInfo::vote())]
 		pub fn vote(
@@ -1001,9 +975,6 @@ pub mod pallet {
 		/// Parameters:
 		/// - `approve`: A boolean which says if the candidate should be
 		/// approved (`true`) or rejected (`false`).
-		///
-		/// Key: M (len of members)
-		/// Total Complexity: O(M + logM)
 		#[pallet::call_index(5)]
 		#[pallet::weight(T::WeightInfo::defender_vote())]
 		pub fn defender_vote(origin: OriginFor<T>, approve: bool) -> DispatchResultWithPostInfo {
@@ -1034,9 +1005,6 @@ pub mod pallet {
 		///
 		/// The dispatch origin for this call must be _Signed_ and a member with
 		/// payouts remaining.
-		///
-		/// Key: M (len of members), P (number of payouts for a particular member)
-		/// Total Complexity: O(M + logM + P + X)
 		#[pallet::call_index(6)]
 		#[pallet::weight(T::WeightInfo::payout())]
 		pub fn payout(origin: OriginFor<T>) -> DispatchResult {
@@ -1129,8 +1097,6 @@ pub mod pallet {
 		/// The dispatch origin for this call must be Signed, and the signing account must be both
 		/// the `Founder` and the `Head`. This implies that it may only be done when there is one
 		/// member.
-		///
-		/// Total Complexity: O(1)
 		#[pallet::call_index(9)]
 		#[pallet::weight(T::WeightInfo::dissolve())]
 		pub fn dissolve(origin: OriginFor<T>) -> DispatchResult {
@@ -1176,9 +1142,6 @@ pub mod pallet {
 		/// - `who` - The suspended member to be judged.
 		/// - `forgive` - A boolean representing whether the suspension judgement origin forgives
 		///   (`true`) or rejects (`false`) a suspended member.
-		///
-		/// Key: B (len of bids), M (len of members)
-		/// Total Complexity: O(M + logM + B)
 		#[pallet::call_index(10)]
 		#[pallet::weight(T::WeightInfo::judge_suspended_member())]
 		pub fn judge_suspended_member(
@@ -1221,8 +1184,6 @@ pub mod pallet {
 		/// - `max_strikes`: The maximum number of strikes a member may get before they become
 		///   suspended and may only be reinstated by the founder.
 		/// - `candidate_deposit`: The deposit required to make a bid for membership of the group.
-		///
-		/// Total Complexity: O(1)
 		#[pallet::call_index(11)]
 		#[pallet::weight(T::WeightInfo::set_parameters())]
 		pub fn set_parameters(
diff --git a/frame/society/src/migrations.rs b/frame/society/src/migrations.rs
index 32db4d35e46d9..54a6abac499ae 100644
--- a/frame/society/src/migrations.rs
+++ b/frame/society/src/migrations.rs
@@ -18,6 +18,7 @@
 //! # Migrations for Society Pallet
 
 use super::*;
+use codec::{Decode, Encode};
 use frame_support::traits::{Instance, OnRuntimeUpgrade};
 
 #[cfg(feature = "try-runtime")]
@@ -43,7 +44,7 @@ impl<
 			can_migrate::<T, I>(),
 			"Invalid (perhaps already-migrated) state detected prior to migration"
 		);
-		Ok(Vec::new())
+		Ok((old::Candidates::<T, I>::get(), old::Members::<T, I>::get()).encode())
 	}
 
 	fn on_runtime_upgrade() -> Weight {
@@ -51,7 +52,26 @@ impl<
 	}
 
 	#[cfg(feature = "try-runtime")]
-	fn post_upgrade(_: Vec<u8>) -> Result<(), TryRuntimeError> {
+	fn post_upgrade(data: Vec<u8>) -> Result<(), TryRuntimeError> {
+		let old: (
+			Vec<Bid<<T as frame_system::Config>::AccountId, BalanceOf<T, I>>>,
+			Vec<<T as frame_system::Config>::AccountId>,
+		) = Decode::decode(&mut &data[..]).expect("Bad data");
+		let mut old_candidates =
+			old.0.into_iter().map(|x| (x.who, x.kind, x.value)).collect::<Vec<_>>();
+		let mut old_members = old.1;
+		let mut candidates =
+			Candidates::<T, I>::iter().map(|(k, v)| (k, v.kind, v.bid)).collect::<Vec<_>>();
+		let mut members = Members::<T, I>::iter_keys().collect::<Vec<_>>();
+
+		old_candidates.sort_by_key(|x| x.0.clone());
+		candidates.sort_by_key(|x| x.0.clone());
+		assert_eq!(candidates, old_candidates);
+
+		members.sort();
+		old_members.sort();
+		assert_eq!(members, old_members);
+
 		assert_internal_consistency::<T, I>();
 		Ok(())
 	}
@@ -289,8 +309,3 @@ pub fn from_raw_past_payouts<T: Config<I>, I: Instance + 'static>(
 		.filter_map(|(x, y)| Some((Decode::decode(&mut &x[..]).ok()?, y.try_into().ok()?)))
 		.collect()
 }
-
-//	use hex_literal::hex;
-//	let mut past_payouts_raw = vec![
-//		(hex!["1234567890123456789012345678901234567890123456789012345678901234"], 0u128),
-//	];

From af65cf78b155d8de2d16e17a316d3d8a4f9c9261 Mon Sep 17 00:00:00 2001
From: Gav <gavin@parity.io>
Date: Thu, 15 Jun 2023 12:01:04 +0100
Subject: [PATCH 42/43] Use pallet storage version

---
 frame/society/src/lib.rs        |  4 ++++
 frame/society/src/migrations.rs | 28 +++++++++++++++++++++++-----
 2 files changed, 27 insertions(+), 5 deletions(-)

diff --git a/frame/society/src/lib.rs b/frame/society/src/lib.rs
index b4b3aecce71c1..6f42ae00f287d 100644
--- a/frame/society/src/lib.rs
+++ b/frame/society/src/lib.rs
@@ -264,6 +264,7 @@ use frame_support::{
 	traits::{
 		BalanceStatus, Currency, EnsureOrigin, EnsureOriginWithArg,
 		ExistenceRequirement::AllowDeath, Imbalance, OnUnbalanced, Randomness, ReservableCurrency,
+		StorageVersion,
 	},
 	PalletId,
 };
@@ -469,7 +470,10 @@ pub type GroupParamsFor<T, I> = GroupParams<BalanceOf<T, I>>;
 pub mod pallet {
 	use super::*;
 
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(2);
+
 	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
 	#[pallet::without_storage_info]
 	pub struct Pallet<T, I = ()>(_);
 
diff --git a/frame/society/src/migrations.rs b/frame/society/src/migrations.rs
index 54a6abac499ae..bd590f9b18770 100644
--- a/frame/society/src/migrations.rs
+++ b/frame/society/src/migrations.rs
@@ -40,15 +40,28 @@ impl<
 {
 	#[cfg(feature = "try-runtime")]
 	fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
-		assert!(
-			can_migrate::<T, I>(),
-			"Invalid (perhaps already-migrated) state detected prior to migration"
-		);
+		ensure!(can_migrate::<T, I>(), "pallet_society: already upgraded");
+
+		let current = Pallet::<T, I>::current_storage_version();
+		let onchain = Pallet::<T, I>::on_chain_storage_version();
+		ensure!(onchain == 0 && current == 2, "pallet_society: invalid version");
+
 		Ok((old::Candidates::<T, I>::get(), old::Members::<T, I>::get()).encode())
 	}
 
 	fn on_runtime_upgrade() -> Weight {
-		from_original::<T, I>(&mut PastPayouts::get())
+		let current = Pallet::<T, I>::current_storage_version();
+		let onchain = Pallet::<T, I>::on_chain_storage_version();
+		if current == 2 && onchain == 0 {
+			from_original::<T, I>(&mut PastPayouts::get())
+		} else {
+			log::info!(
+				"Running migration with current storage version {:?} / onchain {:?}",
+				current,
+				onchain
+			);
+			T::DbWeight::get().reads(1)
+		}
 	}
 
 	#[cfg(feature = "try-runtime")]
@@ -72,6 +85,11 @@ impl<
 		old_members.sort();
 		assert_eq!(members, old_members);
 
+		ensure!(
+			Pallet::<T, I>::on_chain_storage_version() == 2,
+			"The onchain version must be updated after the migration."
+		);
+
 		assert_internal_consistency::<T, I>();
 		Ok(())
 	}

From 308e6464204d855f18ad0bfd931148cdb2b5dfea Mon Sep 17 00:00:00 2001
From: Gav <gavin@parity.io>
Date: Thu, 15 Jun 2023 12:05:29 +0100
Subject: [PATCH 43/43] Fix up society cargo toml file

---
 frame/society/Cargo.toml | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/frame/society/Cargo.toml b/frame/society/Cargo.toml
index 7bd2124f132f9..ec5ab04e35ec4 100644
--- a/frame/society/Cargo.toml
+++ b/frame/society/Cargo.toml
@@ -13,10 +13,12 @@ readme = "README.md"
 targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
-codec = { package = "parity-scale-codec", version = "3.2.2", default-features = false, features = ["derive"] }
+hex-literal = "0.3.4"
 log = { version = "0.4.17", default-features = false }
 rand_chacha = { version = "0.2", default-features = false }
 scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.2.2", default-features = false, features = ["derive"] }
+
 sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
 sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
 sp-arithmetic = { version = "16.0.0", default-features = false, path = "../../primitives/arithmetic" }
@@ -24,7 +26,6 @@ sp-runtime = { version = "24.0.0", default-features = false, path = "../../primi
 frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
 frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
 frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
-hex-literal = "0.3.4"
 
 [dev-dependencies]
 frame-support-test = { version = "3.0.0", path = "../support/test" }
@@ -36,6 +37,7 @@ sp-io = { version = "23.0.0", path = "../../primitives/io" }
 default = ["std"]
 std = [
 	"codec/std",
+	"frame-benchmarking?/std",
 	"frame-support/std",
 	"frame-system/std",
 	"rand_chacha/std",
@@ -45,6 +47,7 @@ std = [
 	"sp-io/std",
 ]
 runtime-benchmarks = [
+	"frame-benchmarking",
 	"sp-runtime/runtime-benchmarks",
 	"frame-benchmarking/runtime-benchmarks",
 	"frame-support/runtime-benchmarks",