Merge branch 'main' into loc_conv_test

CHANGELOG.md

@@ -4,6 +4,12 @@ Changelog for the runtimes governed by the Polkadot Fellowship.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## [Unreleased]
+
+### Changed
+
+Change Polkadot inflation to 120M DOT per year ([polkadot-fellows/runtimes#471](https://github.com/polkadot-fellows/runtimes/pull/471))
+
 ## [1.3.3] 01.10.2024
 
 ### Changed

Cargo.toml

@@ -7,6 +7,7 @@ license = "GPL-3.0-only"                                        # TODO <https://
 
 [workspace.dependencies]
 assert_matches = { version = "1.5.0" }
+approx = { version = "0.5.1" }
 asset-hub-kusama-emulated-chain = { path = "integration-tests/emulated/chains/parachains/assets/asset-hub-kusama" }
 asset-hub-kusama-runtime = { path = "system-parachains/asset-hubs/asset-hub-kusama" }
 asset-hub-polkadot-emulated-chain = { path = "integration-tests/emulated/chains/parachains/assets/asset-hub-polkadot" }

relay/polkadot/Cargo.toml

@@ -110,6 +110,7 @@ sp-debug-derive = { workspace = true }
 polkadot-parachain-primitives = { workspace = true }
 
 [dev-dependencies]
+approx = { workspace = true }
 sp-keyring = { workspace = true }
 sp-trie = { workspace = true }
 separator = { workspace = true }

relay/polkadot/src/lib.rs

@@ -700,39 +700,31 @@ impl pallet_parameters::Config for Runtime {
 	type AdminOrigin = DynamicParameterOrigin;
 	type WeightInfo = weights::pallet_parameters::WeightInfo<Runtime>;
 }
+
 /// Defines how much should the inflation be for an era given its duration.
 pub struct EraPayout;
 impl pallet_staking::EraPayout<Balance> for EraPayout {
 	fn era_payout(
-		total_staked: Balance,
+		_total_staked: Balance,
 		_total_issuance: Balance,
 		era_duration_millis: u64,
 	) -> (Balance, Balance) {
-		const MILLISECONDS_PER_YEAR: u64 = 1000 * 3600 * 24 * 36525 / 100;
-
-		let params = relay_common::EraPayoutParams {
-			total_staked,
-			total_stakable: Balances::total_issuance(),
-			ideal_stake: dynamic_params::inflation::IdealStake::get(),
-			max_annual_inflation: dynamic_params::inflation::MaxInflation::get(),
-			min_annual_inflation: dynamic_params::inflation::MinInflation::get(),
-			falloff: dynamic_params::inflation::Falloff::get(),
-			period_fraction: Perquintill::from_rational(era_duration_millis, MILLISECONDS_PER_YEAR),
-			legacy_auction_proportion: if dynamic_params::inflation::UseAuctionSlots::get() {
-				let auctioned_slots = parachains_paras::Parachains::<Runtime>::get()
-					.into_iter()
-					// all active para-ids that do not belong to a system chain is the number of
-					// parachains that we should take into account for inflation.
-					.filter(|i| *i >= LOWEST_PUBLIC_ID)
-					.count() as u64;
-				Some(Perquintill::from_rational(auctioned_slots.min(60), 300u64))
-			} else {
-				None
-			},
-		};
+		const MILLISECONDS_PER_YEAR: u64 = (1000 * 3600 * 24 * 36525) / 100;
+		// A normal-sized era will have 1 / 365.25 here:
+		let relative_era_len =
+			FixedU128::from_rational(era_duration_millis.into(), MILLISECONDS_PER_YEAR.into());
+
+		// TI at the time of execution of [Referendum 1139](https://polkadot.subsquare.io/referenda/1139), block hash: `0x39422610299a75ef69860417f4d0e1d94e77699f45005645ffc5e8e619950f9f`.
+		let fixed_total_issuance: i128 = 15_011_657_390_566_252_333;
+		let fixed_inflation_rate = FixedU128::from_rational(8, 100);
+		let yearly_emission = fixed_inflation_rate.saturating_mul_int(fixed_total_issuance);
 
-		log::debug!(target: LOG_TARGET, "params: {:?}", params);
-		relay_common::relay_era_payout(params)
+		let era_emission = relative_era_len.saturating_mul_int(yearly_emission);
+		// 15% to treasury, as per ref 1139.
+		let to_treasury = FixedU128::from_rational(15, 100).saturating_mul_int(era_emission);
+		let to_stakers = era_emission.saturating_sub(to_treasury);
+
+		(to_stakers.saturated_into(), to_treasury.saturated_into())
 	}
 }
 
@@ -3377,6 +3369,7 @@ mod multiplier_tests {
 		dispatch::DispatchInfo,
 		traits::{OnFinalize, PalletInfoAccess},
 	};
+	use pallet_staking::EraPayout;
 	use polkadot_runtime_common::{MinimumMultiplier, TargetBlockFullness};
 	use separator::Separatable;
 	use sp_runtime::traits::Convert;
@@ -3408,6 +3401,113 @@ mod multiplier_tests {
 		})
 	}
 
+	use approx::assert_relative_eq;
+	const MILLISECONDS_PER_DAY: u64 = 24 * 60 * 60 * 1000;
+
+	#[test]
+	fn staking_inflation_correct_single_era() {
+		let (to_stakers, to_treasury) = super::EraPayout::era_payout(
+			123, // ignored
+			456, // ignored
+			MILLISECONDS_PER_DAY,
+		);
+
+		// Values are within 0.1%
+		assert_relative_eq!(to_stakers as f64, (279_477 * UNITS) as f64, max_relative = 0.001);
+		assert_relative_eq!(to_treasury as f64, (49_320 * UNITS) as f64, max_relative = 0.001);
+		// Total per day is ~328,797 DOT
+		assert_relative_eq!(
+			(to_stakers as f64 + to_treasury as f64),
+			(328_797 * UNITS) as f64,
+			max_relative = 0.001
+		);
+	}
+
+	#[test]
+	fn staking_inflation_correct_longer_era() {
+		// Twice the era duration means twice the emission:
+		let (to_stakers, to_treasury) = super::EraPayout::era_payout(
+			123, // ignored
+			456, // ignored
+			2 * MILLISECONDS_PER_DAY,
+		);
+
+		assert_relative_eq!(
+			to_stakers as f64,
+			(279_477 * UNITS) as f64 * 2.0,
+			max_relative = 0.001
+		);
+		assert_relative_eq!(
+			to_treasury as f64,
+			(49_320 * UNITS) as f64 * 2.0,
+			max_relative = 0.001
+		);
+	}
+
+	#[test]
+	fn staking_inflation_correct_whole_year() {
+		let (to_stakers, to_treasury) = super::EraPayout::era_payout(
+			123,                                  // ignored
+			456,                                  // ignored
+			(36525 * MILLISECONDS_PER_DAY) / 100, // 1 year
+		);
+
+		// Our yearly emissions is about 120M DOT:
+		let yearly_emission = 120_093_259 * UNITS;
+		assert_relative_eq!(
+			to_stakers as f64 + to_treasury as f64,
+			yearly_emission as f64,
+			max_relative = 0.001
+		);
+
+		assert_relative_eq!(to_stakers as f64, yearly_emission as f64 * 0.85, max_relative = 0.001);
+		assert_relative_eq!(
+			to_treasury as f64,
+			yearly_emission as f64 * 0.15,
+			max_relative = 0.001
+		);
+	}
+
+	// 10 years into the future, our values do not overflow.
+	#[test]
+	fn staking_inflation_correct_not_overflow() {
+		let (to_stakers, to_treasury) = super::EraPayout::era_payout(
+			123,                                 // ignored
+			456,                                 // ignored
+			(36525 * MILLISECONDS_PER_DAY) / 10, // 10 years
+		);
+		let initial_ti: i128 = 15_011_657_390_566_252_333;
+		let projected_total_issuance = (to_stakers as i128 + to_treasury as i128) + initial_ti;
+
+		// In 2034, there will be about 2.7 billion DOT in existence.
+		assert_relative_eq!(
+			projected_total_issuance as f64,
+			(2_700_000_000 * UNITS) as f64,
+			max_relative = 0.001
+		);
+	}
+
+	// Print percent per year, just as convenience.
+	#[test]
+	fn staking_inflation_correct_print_percent() {
+		let (to_stakers, to_treasury) = super::EraPayout::era_payout(
+			123,                                  // ignored
+			456,                                  // ignored
+			(36525 * MILLISECONDS_PER_DAY) / 100, // 1 year
+		);
+		let yearly_emission = to_stakers + to_treasury;
+		let mut ti: i128 = 15_011_657_390_566_252_333;
+
+		for y in 0..10 {
+			let new_ti = ti + yearly_emission as i128;
+			let inflation = 100.0 * (new_ti - ti) as f64 / ti as f64;
+			println!("Year {y} inflation: {inflation}%");
+			ti = new_ti;
+
+			assert!(inflation <= 8.0 && inflation > 2.0, "sanity check");
+		}
+	}
+
 	#[test]
 	fn fast_unstake_estimate() {
 		use pallet_fast_unstake::WeightInfo;