Rejig 'turnout' as 'support'

bin/node/runtime/src/lib.rs

@@ -739,7 +739,7 @@ impl pallet_referenda::TracksInfo<Balance, BlockNumber> for TracksInfo {
 					begin: Perbill::from_percent(100),
 					delta: Perbill::from_percent(50),
 				},
-				min_turnout: pallet_referenda::Curve::LinearDecreasing {
+				min_support: pallet_referenda::Curve::LinearDecreasing {
 					begin: Perbill::from_percent(100),
 					delta: Perbill::from_percent(100),
 				},

frame/conviction-voting/src/types.rs

@@ -54,8 +54,8 @@ pub struct Tally<
 	pub ayes: Votes,
 	/// The number of nay votes, expressed in terms of post-conviction lock-vote.
 	pub nays: Votes,
-	/// The amount of funds currently expressing its opinion. Pre-conviction.
-	pub turnout: Votes,
+	/// The basic number of aye votes, expressed pre-conviction.
+	pub support: Votes,
 	/// Dummy.
 	dummy: PhantomData<Total>,
 }
@@ -77,8 +77,8 @@ impl<
 		self.ayes
 	}
 
-	fn turnout(&self) -> Perbill {
-		Perbill::from_rational(self.turnout, Total::get())
+	fn support(&self) -> Perbill {
+		Perbill::from_rational(self.support, Total::get())
 	}
 
 	fn approval(&self) -> Perbill {
@@ -87,14 +87,15 @@ impl<
 
 	#[cfg(feature = "runtime-benchmarks")]
 	fn unanimity() -> Self {
-		Self { ayes: Total::get(), nays: Zero::zero(), turnout: Total::get(), dummy: PhantomData }
+		Self { ayes: Total::get(), nays: Zero::zero(), support: Total::get(), dummy: PhantomData }
 	}
 
 	#[cfg(feature = "runtime-benchmarks")]
-	fn from_requirements(turnout: Perbill, approval: Perbill) -> Self {
-		let turnout = turnout.mul_ceil(Total::get());
-		let ayes = approval.mul_ceil(turnout);
-		Self { ayes, nays: turnout - ayes, turnout, dummy: PhantomData }
+	fn from_requirements(support: Perbill, approval: Perbill) -> Self {
+		let support = support.mul_ceil(Total::get());
+		let ayes = approval.mul_ceil(support);
+		// TODO
+		Self { ayes, nays: support - ayes, support, dummy: PhantomData }
 	}
 }
 
@@ -117,30 +118,37 @@ impl<
 		Self {
 			ayes: if vote.aye { votes } else { Zero::zero() },
 			nays: if vote.aye { Zero::zero() } else { votes },
-			turnout: capital,
+			support: capital,
 			dummy: PhantomData,
 		}
 	}
 
-	pub fn from_parts(ayes: Votes, nays: Votes, turnout: Votes) -> Self {
-		Self { ayes, nays, turnout, dummy: PhantomData }
+	pub fn from_parts(ayes_with_conviction: Votes, nays_with_conviction: Votes, ayes: Votes) -> Self {
+		Self {
+			ayes: ayes_with_conviction,
+			nays: nays_with_conviction,
+			support: ayes,
+			dummy: PhantomData,
+		}
 	}
 
 	/// Add an account's vote into the tally.
 	pub fn add(&mut self, vote: AccountVote<Votes>) -> Option<()> {
 		match vote {
 			AccountVote::Standard { vote, balance } => {
 				let Delegations { votes, capital } = vote.conviction.votes(balance);
-				self.turnout = self.turnout.checked_add(&capital)?;
 				match vote.aye {
-					true => self.ayes = self.ayes.checked_add(&votes)?,
+					true => {
+						self.support = self.support.checked_add(&capital)?;
+						self.ayes = self.ayes.checked_add(&votes)?
+					},
 					false => self.nays = self.nays.checked_add(&votes)?,
 				}
 			},
 			AccountVote::Split { aye, nay } => {
 				let aye = Conviction::None.votes(aye);
 				let nay = Conviction::None.votes(nay);
-				self.turnout = self.turnout.checked_add(&aye.capital)?.checked_add(&nay.capital)?;
+				self.support = self.support.checked_add(&aye.capital)?;
 				self.ayes = self.ayes.checked_add(&aye.votes)?;
 				self.nays = self.nays.checked_add(&nay.votes)?;
 			},
@@ -153,16 +161,19 @@ impl<
 		match vote {
 			AccountVote::Standard { vote, balance } => {
 				let Delegations { votes, capital } = vote.conviction.votes(balance);
-				self.turnout = self.turnout.checked_sub(&capital)?;
 				match vote.aye {
-					true => self.ayes = self.ayes.checked_sub(&votes)?,
+					true => {
+						self.support = self.support.checked_sub(&capital)?;
+						self.ayes = self.ayes.checked_sub(&votes)?
+					},
 					false => self.nays = self.nays.checked_sub(&votes)?,
 				}
 			},
+			// TODO: abstain.
 			AccountVote::Split { aye, nay } => {
 				let aye = Conviction::None.votes(aye);
 				let nay = Conviction::None.votes(nay);
-				self.turnout = self.turnout.checked_sub(&aye.capital)?.checked_sub(&nay.capital)?;
+				self.support = self.support.checked_sub(&aye.capital)?;
 				self.ayes = self.ayes.checked_sub(&aye.votes)?;
 				self.nays = self.nays.checked_sub(&nay.votes)?;
 			},
@@ -172,18 +183,22 @@ impl<
 
 	/// Increment some amount of votes.
 	pub fn increase(&mut self, approve: bool, delegations: Delegations<Votes>) {
-		self.turnout = self.turnout.saturating_add(delegations.capital);
 		match approve {
-			true => self.ayes = self.ayes.saturating_add(delegations.votes),
+			true => {
+				self.support = self.support.saturating_add(delegations.capital);
+				self.ayes = self.ayes.saturating_add(delegations.votes);
+			},
 			false => self.nays = self.nays.saturating_add(delegations.votes),
 		}
 	}
 
 	/// Decrement some amount of votes.
 	pub fn reduce(&mut self, approve: bool, delegations: Delegations<Votes>) {
-		self.turnout = self.turnout.saturating_sub(delegations.capital);
 		match approve {
-			true => self.ayes = self.ayes.saturating_sub(delegations.votes),
+			true => {
+				self.support = self.support.saturating_sub(delegations.capital);
+				self.ayes = self.ayes.saturating_sub(delegations.votes);
+			},
 			false => self.nays = self.nays.saturating_sub(delegations.votes),
 		}
 	}
@@ -196,7 +211,7 @@ impl<
 pub struct Delegations<Balance> {
 	/// The number of votes (this is post-conviction).
 	pub votes: Balance,
-	/// The amount of raw capital, used for the turnout.
+	/// The amount of raw capital, used for the support.
 	pub capital: Balance,
 }
 

frame/referenda/src/benchmarking.rs

@@ -104,11 +104,11 @@ fn info<T: Config>(index: ReferendumIndex) -> &'static TrackInfoOf<T> {
 }
 
 fn make_passing_after<T: Config>(index: ReferendumIndex, period_portion: Perbill) {
-	let turnout = info::<T>(index).min_turnout.threshold(period_portion);
+	let support = info::<T>(index).min_support.threshold(period_portion);
 	let approval = info::<T>(index).min_approval.threshold(period_portion);
 	Referenda::<T>::access_poll(index, |status| {
 		if let PollStatus::Ongoing(tally, ..) = status {
-			*tally = T::Tally::from_requirements(turnout, approval);
+			*tally = T::Tally::from_requirements(support, approval);
 		}
 	});
 }

frame/referenda/src/lib.rs

@@ -41,7 +41,7 @@
 //! In order to become concluded, one of three things must happen:
 //! - The referendum should remain in an unbroken _Passing_ state for a period of time. This
 //! is known as the _Confirmation Period_ and is determined by the track. A referendum is considered
-//! _Passing_ when there is a sufficiently high turnout and approval, given the amount of time it
+//! _Passing_ when there is a sufficiently high support and approval, given the amount of time it
 //! has been being decided. Generally the threshold for what counts as being "sufficiently high"
 //! will reduce over time. The curves setting these thresholds are determined by the track. In this
 //! case, the referendum is considered _Approved_ and the proposal is scheduled for dispatch.
@@ -54,6 +54,10 @@
 //!
 //! Once a referendum is concluded, the decision deposit may be refunded.
 //!
+//! ## Terms
+//! - *Support*: The number of aye-votes, pre-conviction, as a proportion of the total number of
+//!   pre-conviction votes able to be cast in the population.
+//!
 //! - [`Config`]
 //! - [`Call`]
 
@@ -723,7 +727,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 			&status.tally,
 			Zero::zero(),
 			track.decision_period,
-			&track.min_turnout,
+			&track.min_support,
 			&track.min_approval,
 		);
 		status.in_queue = false;
@@ -930,7 +934,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 					&status.tally,
 					now.saturating_sub(deciding.since),
 					track.decision_period,
-					&track.min_turnout,
+					&track.min_support,
 					&track.min_approval,
 				);
 				branch = if is_passing {
@@ -1014,10 +1018,10 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		deciding.confirming.unwrap_or_else(|| {
 			// Set alarm to the point where the current voting would make it pass.
 			let approval = tally.approval();
-			let turnout = tally.turnout();
+			let support = tally.support();
 			let until_approval = track.min_approval.delay(approval);
-			let until_turnout = track.min_turnout.delay(turnout);
-			let offset = until_turnout.max(until_approval);
+			let until_support = track.min_support.delay(support);
+			let offset = until_support.max(until_approval);
 			deciding.since.saturating_add(offset * track.decision_period)
 		})
 	}
@@ -1062,16 +1066,16 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	}
 
 	/// Determine whether the given `tally` would result in a referendum passing at `elapsed` blocks
-	/// into a total decision `period`, given the two curves for `turnout_needed` and
+	/// into a total decision `period`, given the two curves for `support_needed` and
 	/// `approval_needed`.
 	fn is_passing(
 		tally: &T::Tally,
 		elapsed: T::BlockNumber,
 		period: T::BlockNumber,
-		turnout_needed: &Curve,
+		support_needed: &Curve,
 		approval_needed: &Curve,
 	) -> bool {
 		let x = Perbill::from_rational(elapsed.min(period), period);
-		turnout_needed.passing(x, tally.turnout()) && approval_needed.passing(x, tally.approval())
+		support_needed.passing(x, tally.support()) && approval_needed.passing(x, tally.approval())
 	}
 }

frame/referenda/src/mock.rs

@@ -175,7 +175,7 @@ impl TracksInfo<u64, u64> for TestTracksInfo {
 						length: Perbill::from_percent(100),
 						floor: Perbill::from_percent(50),
 					},
-					min_turnout: Curve::LinearDecreasing {
+					min_support: Curve::LinearDecreasing {
 						length: Perbill::from_percent(100),
 						floor: Perbill::from_percent(100),
 					},
@@ -195,7 +195,7 @@ impl TracksInfo<u64, u64> for TestTracksInfo {
 						length: Perbill::from_percent(55),
 						floor: Perbill::from_percent(5),
 					},
-					min_turnout: Curve::LinearDecreasing {
+					min_support: Curve::LinearDecreasing {
 						length: Perbill::from_percent(10),
 						floor: Perbill::from_percent(10),
 					},
@@ -264,8 +264,8 @@ impl VoteTally<u32> for Tally {
 		self.ayes
 	}
 
-	fn turnout(&self) -> Perbill {
-		Perbill::from_percent(self.ayes + self.nays)
+	fn support(&self) -> Perbill {
+		Perbill::from_percent(self.ayes)
 	}
 
 	fn approval(&self) -> Perbill {
@@ -278,10 +278,10 @@ impl VoteTally<u32> for Tally {
 	}
 
 	#[cfg(feature = "runtime-benchmarks")]
-	fn from_requirements(turnout: Perbill, approval: Perbill) -> Self {
-		let turnout = turnout.mul_ceil(100u32);
-		let ayes = approval.mul_ceil(turnout);
-		Self { ayes, nays: turnout - ayes }
+	fn from_requirements(support: Perbill, approval: Perbill) -> Self {
+		let ayes = support.mul_ceil(100u32);
+		let nays = (ayes * 1_000_000_000u64 / approval.deconstruct() as u64) - ayes;
+		Self { ayes, nays }
 	}
 }
 

frame/referenda/src/types.rs

@@ -128,9 +128,9 @@ pub struct TrackInfo<Balance, Moment> {
 	/// Minimum aye votes as percentage of overall conviction-weighted votes needed for
 	/// approval as a function of time into decision period.
 	pub min_approval: Curve,
-	/// Minimum turnout as percentage of overall population that is needed for
-	/// approval as a function of time into decision period.
-	pub min_turnout: Curve,
+	/// Minimum pre-conviction aye-votes ("support") as percentage of overall population that is
+	/// needed for approval as a function of time into decision period.
+	pub min_support: Curve,
 }
 
 /// Information on the voting tracks.
@@ -493,45 +493,45 @@ mod tests {
 	}
 
 	const TIP_APP: Curve = Curve::make_linear(10, 28, percent(50));
-	const TIP_QUO: Curve = Curve::make_reciprocal(1, 28, percent(4), percent(0));
+	const TIP_SUP: Curve = Curve::make_reciprocal(1, 28, percent(4), percent(0));
 	const ROOT_APP: Curve = Curve::make_reciprocal(4, 28, percent(80), percent(50));
-	const ROOT_QUO: Curve = Curve::make_linear(28, 28, percent(0));
+	const ROOT_SUP: Curve = Curve::make_linear(28, 28, percent(0));
 	const WHITE_APP: Curve = Curve::make_reciprocal(16, 28 * 24, percent(96), percent(50));
-	const WHITE_QUO: Curve = Curve::make_reciprocal(1, 28, percent(20), percent(10));
+	const WHITE_SUP: Curve = Curve::make_reciprocal(1, 28, percent(20), percent(10));
 	const SMALL_APP: Curve = Curve::make_linear(10, 28, percent(50));
-	const SMALL_QUO: Curve = Curve::make_reciprocal(8, 28, percent(1), percent(0));
+	const SMALL_SUP: Curve = Curve::make_reciprocal(8, 28, percent(1), percent(0));
 	const MID_APP: Curve = Curve::make_linear(17, 28, percent(50));
-	const MID_QUO: Curve = Curve::make_reciprocal(12, 28, percent(1), percent(0));
+	const MID_SUP: Curve = Curve::make_reciprocal(12, 28, percent(1), percent(0));
 	const BIG_APP: Curve = Curve::make_linear(23, 28, percent(50));
-	const BIG_QUO: Curve = Curve::make_reciprocal(16, 28, percent(1), percent(0));
+	const BIG_SUP: Curve = Curve::make_reciprocal(16, 28, percent(1), percent(0));
 	const HUGE_APP: Curve = Curve::make_linear(28, 28, percent(50));
-	const HUGE_QUO: Curve = Curve::make_reciprocal(20, 28, percent(1), percent(0));
+	const HUGE_SUP: Curve = Curve::make_reciprocal(20, 28, percent(1), percent(0));
 	const PARAM_APP: Curve = Curve::make_reciprocal(4, 28, percent(80), percent(50));
-	const PARAM_QUO: Curve = Curve::make_reciprocal(7, 28, percent(10), percent(0));
+	const PARAM_SUP: Curve = Curve::make_reciprocal(7, 28, percent(10), percent(0));
 	const ADMIN_APP: Curve = Curve::make_linear(17, 28, percent(50));
-	const ADMIN_QUO: Curve = Curve::make_reciprocal(12, 28, percent(1), percent(0));
+	const ADMIN_SUP: Curve = Curve::make_reciprocal(12, 28, percent(1), percent(0));
 
 	#[test]
 	#[should_panic]
 	fn check_curves() {
 		TIP_APP.info(28u32, "Tip Approval");
-		TIP_QUO.info(28u32, "Tip Quorum");
+		TIP_SUP.info(28u32, "Tip Support");
 		ROOT_APP.info(28u32, "Root Approval");
-		ROOT_QUO.info(28u32, "Root Quorum");
+		ROOT_SUP.info(28u32, "Root Support");
 		WHITE_APP.info(28u32, "Whitelist Approval");
-		WHITE_QUO.info(28u32, "Whitelist Quorum");
+		WHITE_SUP.info(28u32, "Whitelist Support");
 		SMALL_APP.info(28u32, "Small Spend Approval");
-		SMALL_QUO.info(28u32, "Small Spend Quorum");
+		SMALL_SUP.info(28u32, "Small Spend Support");
 		MID_APP.info(28u32, "Mid Spend Approval");
-		MID_QUO.info(28u32, "Mid Spend Quorum");
+		MID_SUP.info(28u32, "Mid Spend Support");
 		BIG_APP.info(28u32, "Big Spend Approval");
-		BIG_QUO.info(28u32, "Big Spend Quorum");
+		BIG_SUP.info(28u32, "Big Spend Support");
 		HUGE_APP.info(28u32, "Huge Spend Approval");
-		HUGE_QUO.info(28u32, "Huge Spend Quorum");
+		HUGE_SUP.info(28u32, "Huge Spend Support");
 		PARAM_APP.info(28u32, "Mid-tier Parameter Change Approval");
-		PARAM_QUO.info(28u32, "Mid-tier Parameter Change Quorum");
+		PARAM_SUP.info(28u32, "Mid-tier Parameter Change Support");
 		ADMIN_APP.info(28u32, "Admin (e.g. Cancel Slash) Approval");
-		ADMIN_QUO.info(28u32, "Admin (e.g. Cancel Slash) Quorum");
+		ADMIN_SUP.info(28u32, "Admin (e.g. Cancel Slash) Support");
 		assert!(false);
 	}
 

frame/support/src/traits/voting.rs

@@ -97,12 +97,12 @@ impl<B: UniqueSaturatedInto<u64> + UniqueSaturatedFrom<u128>> CurrencyToVote<B>
 
 pub trait VoteTally<Votes> {
 	fn ayes(&self) -> Votes;
-	fn turnout(&self) -> Perbill;
+	fn support(&self) -> Perbill;
 	fn approval(&self) -> Perbill;
 	#[cfg(feature = "runtime-benchmarks")]
 	fn unanimity() -> Self;
 	#[cfg(feature = "runtime-benchmarks")]
-	fn from_requirements(turnout: Perbill, approval: Perbill) -> Self;
+	fn from_requirements(support: Perbill, approval: Perbill) -> Self;
 }
 
 pub enum PollStatus<Tally, Moment, Class> {