staking: Flexible generation of reward curve and associated tweaks (#8327)

* Initial abstraction

* Alter rest of APIs

* Fixes

* Some extra getters in Gilt pallet.

* Refactor Gilt to avoid u128 conversions

* Simplify and improve pow in per_things

* Add scalar division to per_things

* Renaming from_fraction -> from_float, drop _approximation

* Fixes

* Fixes

* Fixes

* Fixes

* Make stuff build

* Fixes

* Fixes

* Fixes

* Fixes

* Update .gitignore

Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com>

* Update frame/gilt/src/lib.rs

Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com>

* Update frame/gilt/src/mock.rs

Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com>

* Fixes

* Fixes

* Fixes

Co-authored-by: Shawn Tabrizi <shawntabrizi@gmail.com>
Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com>

substrate/frame/babe/src/equivocation.rs

@@ -290,7 +290,7 @@ impl<FullIdentification: Clone> Offence<FullIdentification>
 
 	fn slash_fraction(offenders_count: u32, validator_set_count: u32) -> Perbill {
 		// the formula is min((3k / n)^2, 1)
-		let x = Perbill::from_rational_approximation(3 * offenders_count, validator_set_count);
+		let x = Perbill::from_rational(3 * offenders_count, validator_set_count);
 		// _ ^ 2
 		x.square()
 	}

substrate/frame/babe/src/lib.rs

@@ -784,7 +784,7 @@ impl<T: Config> frame_support::traits::EstimateNextSessionRotation<T::BlockNumbe
 		let elapsed = CurrentSlot::get().saturating_sub(Self::current_epoch_start()) + 1;
 
 		(
-			Some(Percent::from_rational_approximation(
+			Some(Percent::from_rational(
 				*elapsed,
 				T::EpochDuration::get(),
 			)),

substrate/frame/babe/src/mock.rs

@@ -205,7 +205,7 @@ impl pallet_staking::Config for Test {
 	type SlashCancelOrigin = frame_system::EnsureRoot<Self::AccountId>;
 	type SessionInterface = Self;
 	type UnixTime = pallet_timestamp::Module<Test>;
-	type RewardCurve = RewardCurve;
+	type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
 	type MaxNominatorRewardedPerValidator = MaxNominatorRewardedPerValidator;
 	type NextNewSession = Session;
 	type ElectionLookahead = ElectionLookahead;

substrate/frame/contracts/src/tests.rs

@@ -246,7 +246,7 @@ parameter_types! {
 	pub const DepositPerContract: u64 = 8 * DepositPerStorageByte::get();
 	pub const DepositPerStorageByte: u64 = 10_000;
 	pub const DepositPerStorageItem: u64 = 10_000;
-	pub RentFraction: Perbill = Perbill::from_rational_approximation(4u32, 10_000u32);
+	pub RentFraction: Perbill = Perbill::from_rational(4u32, 10_000u32);
 	pub const SurchargeReward: u64 = 500_000;
 	pub const MaxDepth: u32 = 100;
 	pub const MaxValueSize: u32 = 16_384;

substrate/frame/gilt/src/lib.rs

@@ -78,7 +78,7 @@ pub mod weights;
 pub mod pallet {
 	use sp_std::prelude::*;
 	use sp_arithmetic::{Perquintill, PerThing};
-	use sp_runtime::traits::{Zero, Saturating, SaturatedConversion};
+	use sp_runtime::traits::{Zero, Saturating};
 	use frame_support::traits::{Currency, OnUnbalanced, ReservableCurrency};
 	use frame_support::pallet_prelude::*;
 	use frame_system::pallet_prelude::*;
@@ -96,7 +96,13 @@ pub mod pallet {
 		type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;
 
 		/// Currency type that this works on.
-		type Currency: ReservableCurrency<Self::AccountId>;
+		type Currency: ReservableCurrency<Self::AccountId, Balance=Self::CurrencyBalance>;
+
+		/// Just the `Currency::Balance` type; we have this item to allow us to constrain it to
+		/// `From<u64>`.
+		type CurrencyBalance:
+			sp_runtime::traits::AtLeast32BitUnsigned + codec::FullCodec + Copy
+				+ MaybeSerializeDeserialize + sp_std::fmt::Debug + Default + From<u64>;
 
 		/// Origin required for setting the target proportion to be under gilt.
 		type AdminOrigin: EnsureOrigin<Self::Origin>;
@@ -448,11 +454,10 @@ pub mod pallet {
 			// Multiply the proportion it is by the total issued.
 			let total_issuance = T::Currency::total_issuance().saturating_sub(T::IgnoredIssuance::get());
 			ActiveTotal::<T>::mutate(|totals| {
-				let nongilt_issuance: u128 = total_issuance.saturating_sub(totals.frozen)
-					.saturated_into();
+				let nongilt_issuance = total_issuance.saturating_sub(totals.frozen);
 				let effective_issuance = totals.proportion.left_from_one()
 					.saturating_reciprocal_mul(nongilt_issuance);
-				let gilt_value: BalanceOf<T> = (gilt.proportion * effective_issuance).saturated_into();
+				let gilt_value = gilt.proportion * effective_issuance;
 
 				totals.frozen = totals.frozen.saturating_sub(gilt.amount);
 				totals.proportion = totals.proportion.saturating_sub(gilt.proportion);
@@ -488,7 +493,40 @@ pub mod pallet {
 		}
 	}
 
+	/// Issuance information returned by `issuance()`.
+	pub struct IssuanceInfo<Balance> {
+		/// The balance held in reserve over all active gilts.
+		pub reserved: Balance,
+		/// The issuance not held in reserve for active gilts. Together with `reserved` this sums to
+		/// `Currency::total_issuance`.
+		pub non_gilt: Balance,
+		/// The balance that `reserved` is effectively worth, at present. This is not issued funds
+		/// and could be less than `reserved` (though in most cases should be greater).
+		pub effective: Balance,
+	}
+
 	impl<T: Config> Pallet<T> {
+		/// Get the target amount of Gilts that we're aiming for.
+		pub fn target() -> Perquintill {
+			ActiveTotal::<T>::get().target
+		}
+
+		/// Returns information on the issuance of gilts.
+		pub fn issuance() -> IssuanceInfo<BalanceOf<T>> {
+			let totals = ActiveTotal::<T>::get();
+
+			let total_issuance = T::Currency::total_issuance();
+			let non_gilt = total_issuance.saturating_sub(totals.frozen);
+			let effective = totals.proportion.left_from_one()
+				.saturating_reciprocal_mul(non_gilt);
+
+			IssuanceInfo {
+				reserved: totals.frozen,
+				non_gilt,
+				effective,
+			}
+		}
+
 		/// Attempt to enlarge our gilt-set from bids in order to satisfy our desired target amount
 		/// of funds frozen into gilts.
 		pub fn pursue_target(max_bids: u32) -> Weight {
@@ -497,11 +535,10 @@ pub mod pallet {
 				let missing = totals.target.saturating_sub(totals.proportion);
 
 				let total_issuance = T::Currency::total_issuance().saturating_sub(T::IgnoredIssuance::get());
-				let nongilt_issuance: u128 = total_issuance.saturating_sub(totals.frozen)
-					.saturated_into();
+				let nongilt_issuance = total_issuance.saturating_sub(totals.frozen);
 				let effective_issuance = totals.proportion.left_from_one()
 					.saturating_reciprocal_mul(nongilt_issuance);
-				let intake: BalanceOf<T> = (missing * effective_issuance).saturated_into();
+				let intake = missing * effective_issuance;
 
 				let (bids_taken, queues_hit) = Self::enlarge(intake, max_bids);
 				let first_from_each_queue = T::WeightInfo::pursue_target_per_queue(queues_hit);
@@ -550,13 +587,12 @@ pub mod pallet {
 								qs[queue_index].1 = qs[queue_index].1.saturating_sub(bid.amount);
 
 								// Now to activate the bid...
-								let nongilt_issuance: u128 = total_issuance.saturating_sub(totals.frozen)
-									.saturated_into();
+								let nongilt_issuance = total_issuance.saturating_sub(totals.frozen);
 								let effective_issuance = totals.proportion.left_from_one()
 									.saturating_reciprocal_mul(nongilt_issuance);
-								let n: u128 = amount.saturated_into();
+								let n = amount;
 								let d = effective_issuance;
-								let proportion = Perquintill::from_rational_approximation(n, d);
+								let proportion = Perquintill::from_rational(n, d);
 								let who = bid.who;
 								let index = totals.index;
 								totals.frozen += bid.amount;

substrate/frame/gilt/src/mock.rs

@@ -103,6 +103,7 @@ ord_parameter_types! {
 impl pallet_gilt::Config for Test {
 	type Event = Event;
 	type Currency = Balances;
+	type CurrencyBalance = <Self as pallet_balances::Config>::Balance;
 	type AdminOrigin = frame_system::EnsureSignedBy<One, Self::AccountId>;
 	type Deficit = ();
 	type Surplus = ();

substrate/frame/grandpa/src/equivocation.rs

@@ -358,7 +358,7 @@ impl<FullIdentification: Clone> Offence<FullIdentification>
 
 	fn slash_fraction(offenders_count: u32, validator_set_count: u32) -> Perbill {
 		// the formula is min((3k / n)^2, 1)
-		let x = Perbill::from_rational_approximation(3 * offenders_count, validator_set_count);
+		let x = Perbill::from_rational(3 * offenders_count, validator_set_count);
 		// _ ^ 2
 		x.square()
 	}

substrate/frame/grandpa/src/mock.rs

@@ -211,7 +211,7 @@ impl pallet_staking::Config for Test {
 	type SlashCancelOrigin = frame_system::EnsureRoot<Self::AccountId>;
 	type SessionInterface = Self;
 	type UnixTime = pallet_timestamp::Module<Test>;
-	type RewardCurve = RewardCurve;
+	type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
 	type MaxNominatorRewardedPerValidator = MaxNominatorRewardedPerValidator;
 	type NextNewSession = Session;
 	type ElectionLookahead = ElectionLookahead;

substrate/frame/im-online/src/lib.rs

@@ -100,11 +100,7 @@ use frame_support::{
 	},
 	Parameter,
 };
-use frame_system::ensure_none;
-use frame_system::offchain::{
-	SendTransactionTypes,
-	SubmitTransaction,
-};
+use frame_system::{ensure_none, offchain::{SendTransactionTypes, SubmitTransaction}};
 pub use weights::WeightInfo;
 
 pub mod sr25519 {
@@ -813,7 +809,7 @@ impl<Offender: Clone> Offence<Offender> for UnresponsivenessOffence<Offender> {
 		// basically, 10% can be offline with no slash, but after that, it linearly climbs up to 7%
 		// when 13/30 are offline (around 5% when 1/3 are offline).
 		if let Some(threshold) = offenders.checked_sub(validator_set_count / 10 + 1) {
-			let x = Perbill::from_rational_approximation(3 * threshold, validator_set_count);
+			let x = Perbill::from_rational(3 * threshold, validator_set_count);
 			x.saturating_mul(Perbill::from_percent(7))
 		} else {
 			Perbill::default()

substrate/frame/offences/benchmarking/src/mock.rs

@@ -170,7 +170,7 @@ impl pallet_staking::Config for Test {
 	type SlashCancelOrigin = frame_system::EnsureRoot<Self::AccountId>;
 	type BondingDuration = ();
 	type SessionInterface = Self;
-	type RewardCurve = RewardCurve;
+	type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
 	type NextNewSession = Session;
 	type ElectionLookahead = ();
 	type Call = Call;

substrate/frame/session/benchmarking/src/mock.rs

@@ -175,7 +175,7 @@ impl pallet_staking::Config for Test {
 	type SlashCancelOrigin = frame_system::EnsureRoot<Self::AccountId>;
 	type BondingDuration = ();
 	type SessionInterface = Self;
-	type RewardCurve = RewardCurve;
+	type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
 	type NextNewSession = Session;
 	type ElectionLookahead = ();
 	type Call = Call;

substrate/frame/session/src/lib.rs

@@ -177,12 +177,12 @@ impl<
 		// (0% is never returned).
 		let progress = if now >= offset {
 			let current = (now - offset) % period.clone() + One::one();
-			Some(Percent::from_rational_approximation(
+			Some(Percent::from_rational(
 				current.clone(),
 				period.clone(),
 			))
 		} else {
-			Some(Percent::from_rational_approximation(
+			Some(Percent::from_rational(
 				now + One::one(),
 				offset,
 			))

substrate/frame/staking/fuzzer/src/mock.rs

@@ -185,7 +185,7 @@ impl pallet_staking::Config for Test {
 	type SlashCancelOrigin = frame_system::EnsureRoot<Self::AccountId>;
 	type BondingDuration = ();
 	type SessionInterface = Self;
-	type RewardCurve = RewardCurve;
+	type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
 	type NextNewSession = Session;
 	type ElectionLookahead = ();
 	type Call = Call;

substrate/frame/staking/src/inflation.rs

@@ -38,7 +38,7 @@ pub fn compute_total_payout<N>(
 	// Milliseconds per year for the Julian year (365.25 days).
 	const MILLISECONDS_PER_YEAR: u64 = 1000 * 3600 * 24 * 36525 / 100;
 
-	let portion = Perbill::from_rational_approximation(era_duration as u64, MILLISECONDS_PER_YEAR);
+	let portion = Perbill::from_rational(era_duration as u64, MILLISECONDS_PER_YEAR);
 	let payout = portion * yearly_inflation.calculate_for_fraction_times_denominator(
 		npos_token_staked,
 		total_tokens.clone(),

substrate/frame/staking/src/lib.rs

@@ -782,6 +782,51 @@ impl<T: Config> SessionInterface<<T as frame_system::Config>::AccountId> for T w
 	}
 }
 
+/// Handler for determining how much of a balance should be paid out on the current era.
+pub trait EraPayout<Balance> {
+	/// Determine the payout for this era.
+	///
+	/// Returns the amount to be paid to stakers in this era, as well as whatever else should be
+	/// paid out ("the rest").
+	fn era_payout(
+		total_staked: Balance,
+		total_issuance: Balance,
+		era_duration_millis: u64,
+	) -> (Balance, Balance);
+}
+
+impl<Balance: Default> EraPayout<Balance> for () {
+	fn era_payout(
+		_total_staked: Balance,
+		_total_issuance: Balance,
+		_era_duration_millis: u64,
+	) -> (Balance, Balance) {
+		(Default::default(), Default::default())
+	}
+}
+
+pub struct ConvertCurve<T>(sp_std::marker::PhantomData<T>);
+impl<
+	Balance: AtLeast32BitUnsigned + Clone,
+	T: Get<&'static PiecewiseLinear<'static>>,
+> EraPayout<Balance> for ConvertCurve<T> {
+	fn era_payout(
+		total_staked: Balance,
+		total_issuance: Balance,
+		era_duration_millis: u64,
+	) -> (Balance, Balance) {
+		let (validator_payout, max_payout) = inflation::compute_total_payout(
+			&T::get(),
+			total_staked,
+			total_issuance,
+			// Duration of era; more than u64::MAX is rewarded as u64::MAX.
+			era_duration_millis,
+		);
+		let rest = max_payout.saturating_sub(validator_payout.clone());
+		(validator_payout, rest)
+	}
+}
+
 pub trait Config: frame_system::Config + SendTransactionTypes<Call<Self>> {
 	/// The staking balance.
 	type Currency: LockableCurrency<Self::AccountId, Moment = Self::BlockNumber>;
@@ -838,9 +883,9 @@ pub trait Config: frame_system::Config + SendTransactionTypes<Call<Self>> {
 	/// Interface for interacting with a session module.
 	type SessionInterface: self::SessionInterface<Self::AccountId>;
 
-	/// The NPoS reward curve used to define yearly inflation.
+	/// The payout for validators and the system for the current era.
 	/// See [Era payout](./index.html#era-payout).
-	type RewardCurve: Get<&'static PiecewiseLinear<'static>>;
+	type EraPayout: EraPayout<BalanceOf<Self>>;
 
 	/// Something that can estimate the next session change, accurately or as a best effort guess.
 	type NextNewSession: EstimateNextNewSession<Self::BlockNumber>;
@@ -2413,7 +2458,7 @@ impl<T: Config> Module<T> {
 
 		// This is the fraction of the total reward that the validator and the
 		// nominators will get.
-		let validator_total_reward_part = Perbill::from_rational_approximation(
+		let validator_total_reward_part = Perbill::from_rational(
 			validator_reward_points,
 			total_reward_points,
 		);
@@ -2428,7 +2473,7 @@ impl<T: Config> Module<T> {
 
 		let validator_leftover_payout = validator_total_payout - validator_commission_payout;
 		// Now let's calculate how this is split to the validator.
-		let validator_exposure_part = Perbill::from_rational_approximation(
+		let validator_exposure_part = Perbill::from_rational(
 			exposure.own,
 			exposure.total,
 		);
@@ -2445,7 +2490,7 @@ impl<T: Config> Module<T> {
 		// Lets now calculate how this is split to the nominators.
 		// Reward only the clipped exposures. Note this is not necessarily sorted.
 		for nominator in exposure.others.iter() {
-			let nominator_exposure_part = Perbill::from_rational_approximation(
+			let nominator_exposure_part = Perbill::from_rational(
 				nominator.value,
 				exposure.total,
 			);
@@ -2837,15 +2882,10 @@ impl<T: Config> Module<T> {
 		if let Some(active_era_start) = active_era.start {
 			let now_as_millis_u64 = T::UnixTime::now().as_millis().saturated_into::<u64>();
 
-			let era_duration = now_as_millis_u64 - active_era_start;
-			let (validator_payout, max_payout) = inflation::compute_total_payout(
-				&T::RewardCurve::get(),
-				Self::eras_total_stake(&active_era.index),
-				T::Currency::total_issuance(),
-				// Duration of era; more than u64::MAX is rewarded as u64::MAX.
-				era_duration.saturated_into::<u64>(),
-			);
-			let rest = max_payout.saturating_sub(validator_payout);
+			let era_duration = (now_as_millis_u64 - active_era_start).saturated_into::<u64>();
+			let staked = Self::eras_total_stake(&active_era.index);
+			let issuance = T::Currency::total_issuance();
+			let (validator_payout, rest) = T::EraPayout::era_payout(staked, issuance, era_duration);
 
 			Self::deposit_event(RawEvent::EraPayout(active_era.index, validator_payout, rest));
 

substrate/frame/staking/src/mock.rs

@@ -260,7 +260,7 @@ impl Config for Test {
 	type SlashCancelOrigin = frame_system::EnsureRoot<Self::AccountId>;
 	type BondingDuration = BondingDuration;
 	type SessionInterface = Self;
-	type RewardCurve = RewardCurve;
+	type EraPayout = ConvertCurve<RewardCurve>;
 	type NextNewSession = Session;
 	type ElectionLookahead = ElectionLookahead;
 	type Call = Call;
@@ -670,25 +670,22 @@ pub(crate) fn start_active_era(era_index: EraIndex) {
 }
 
 pub(crate) fn current_total_payout_for_duration(duration: u64) -> Balance {
-	let reward = inflation::compute_total_payout(
-		<Test as Config>::RewardCurve::get(),
+	let (payout, _rest) = <Test as Config>::EraPayout::era_payout(
 		Staking::eras_total_stake(active_era()),
 		Balances::total_issuance(),
 		duration,
-	)
-	.0;
-	assert!(reward > 0);
-	reward
+	);
+	assert!(payout > 0);
+	payout
 }
 
 pub(crate) fn maximum_payout_for_duration(duration: u64) -> Balance {
-	inflation::compute_total_payout(
-		<Test as Config>::RewardCurve::get(),
-		0,
+	let (payout, rest) = <Test as Config>::EraPayout::era_payout(
+		Staking::eras_total_stake(active_era()),
 		Balances::total_issuance(),
 		duration,
-	)
-	.1
+	);
+	payout + rest
 }
 
 /// Time it takes to finish a session.

substrate/frame/staking/src/testing_utils.rs

@@ -376,7 +376,7 @@ pub fn create_assignments_for_offchain<T: Config>(
 	),
 	&'static str
 > {
-	let ratio = OffchainAccuracy::from_rational_approximation(1, MAX_NOMINATIONS);
+	let ratio = OffchainAccuracy::from_rational(1, MAX_NOMINATIONS);
 	let assignments: Vec<Assignment<T::AccountId, OffchainAccuracy>> = <Nominators<T>>::iter()
 		.take(num_assignments as usize)
 		.map(|(n, t)| Assignment {

substrate/frame/staking/src/tests.rs

@@ -209,10 +209,10 @@ fn rewards_should_work() {
 				individual: vec![(11, 100), (21, 50)].into_iter().collect(),
 			}
 		);
-		let part_for_10 = Perbill::from_rational_approximation::<u32>(1000, 1125);
-		let part_for_20 = Perbill::from_rational_approximation::<u32>(1000, 1375);
-		let part_for_100_from_10 = Perbill::from_rational_approximation::<u32>(125, 1125);
-		let part_for_100_from_20 = Perbill::from_rational_approximation::<u32>(375, 1375);
+		let part_for_10 = Perbill::from_rational::<u32>(1000, 1125);
+		let part_for_20 = Perbill::from_rational::<u32>(1000, 1375);
+		let part_for_100_from_10 = Perbill::from_rational::<u32>(125, 1125);
+		let part_for_100_from_20 = Perbill::from_rational::<u32>(375, 1375);
 
 		start_session(2);
 		start_session(3);
@@ -598,8 +598,8 @@ fn nominators_also_get_slashed_pro_rata() {
 
 		let slash_amount = slash_percent * exposed_stake;
 		let validator_share =
-			Perbill::from_rational_approximation(exposed_validator, exposed_stake) * slash_amount;
-		let nominator_share = Perbill::from_rational_approximation(
+			Perbill::from_rational(exposed_validator, exposed_stake) * slash_amount;
+		let nominator_share = Perbill::from_rational(
 			exposed_nominator,
 			exposed_stake,
 		) * slash_amount;
@@ -4270,8 +4270,8 @@ fn claim_reward_at_the_last_era_and_no_double_claim_and_invalid_claim() {
 		let init_balance_10 = Balances::total_balance(&10);
 		let init_balance_100 = Balances::total_balance(&100);
 
-		let part_for_10 = Perbill::from_rational_approximation::<u32>(1000, 1125);
-		let part_for_100 = Perbill::from_rational_approximation::<u32>(125, 1125);
+		let part_for_10 = Perbill::from_rational::<u32>(1000, 1125);
+		let part_for_100 = Perbill::from_rational::<u32>(125, 1125);
 
 		// Check state
 		Payee::<Test>::insert(11, RewardDestination::Controller);

substrate/frame/support/src/weights.rs

@@ -130,11 +130,8 @@
 #[cfg(feature = "std")]
 use serde::{Serialize, Deserialize};
 use codec::{Encode, Decode};
-use sp_runtime::{
-	RuntimeDebug,
-	traits::SignedExtension,
-	generic::{CheckedExtrinsic, UncheckedExtrinsic},
-};
+use sp_runtime::{RuntimeDebug, traits::SignedExtension};
+use sp_runtime::generic::{CheckedExtrinsic, UncheckedExtrinsic};
 use crate::dispatch::{DispatchErrorWithPostInfo, DispatchResultWithPostInfo, DispatchError};
 use sp_runtime::traits::SaturatedConversion;
 use sp_arithmetic::{Perbill, traits::{BaseArithmetic, Saturating, Unsigned}};
@@ -964,13 +961,13 @@ mod tests {
 			smallvec![
 				WeightToFeeCoefficient {
 					coeff_integer: 0,
-					coeff_frac: Perbill::from_fraction(0.5),
+					coeff_frac: Perbill::from_float(0.5),
 					negative: false,
 					degree: 3
 				},
 				WeightToFeeCoefficient {
 					coeff_integer: 2,
-					coeff_frac: Perbill::from_rational_approximation(1u32, 3u32),
+					coeff_frac: Perbill::from_rational(1u32, 3u32),
 					negative: false,
 					degree: 2
 				},