Move era reward minting to DAP with era-based allocation in Staking

cumulus/parachains/runtimes/assets/asset-hub-westend/src/lib.rs

@@ -96,7 +96,7 @@ use sp_version::RuntimeVersion;
 use testnet_parachains_constants::westend::{
 	consensus::*, currency::*, snowbridge::EthereumNetwork, time::*,
 };
-use westend_runtime_constants::time::DAYS as RC_DAYS;
+use westend_runtime_constants::time::{DAYS as RC_DAYS, HOURS as RC_HOURS};
 use xcm_config::{
 	ForeignAssetsConvertedConcreteId, LocationToAccountId, PoolAssetsConvertedConcreteId,
 	PoolAssetsPalletLocation, TrustBackedAssetsConvertedConcreteId,
@@ -1581,6 +1581,37 @@ parameter_types! {
 	);
 }
 
+/// Provides the initial `LastIssuanceTimestamp` for DAP migration.
+pub struct DapLastIssuanceTimestamp;
+impl frame_support::traits::Get<u64> for DapLastIssuanceTimestamp {
+	fn get() -> u64 {
+		pallet_staking_async::ActiveEra::<Runtime>::get()
+			.and_then(|era| era.start)
+			.unwrap_or(0)
+	}
+}
+
+/// Default budget: 85% staker rewards, 15% buffer, 0% validator incentive.
+///
+/// Keys are read from `BudgetRecipients` registered in the runtime config.
+pub struct DefaultDapBudget;
+impl frame_support::traits::Get<pallet_dap::BudgetAllocationMap> for DefaultDapBudget {
+	fn get() -> pallet_dap::BudgetAllocationMap {
+		use sp_runtime::Perbill;
+		use sp_staking::budget::BudgetRecipientList;
+
+		let recipients = <Runtime as pallet_dap::Config>::BudgetRecipients::recipients();
+		// [dap, StakerRewardRecipient, ValidatorIncentiveRecipient]
+		let percentages = [Perbill::from_percent(15), Perbill::from_percent(85), Perbill::zero()];
+
+		let mut map = pallet_dap::BudgetAllocationMap::new();
+		for ((key, _), perbill) in recipients.into_iter().zip(percentages) {
+			let _ = map.try_insert(key, perbill);
+		}
+		map
+	}
+}
+
 /// Migrations to apply on runtime upgrade.
 pub type Migrations = (
 	// v9420
@@ -1620,6 +1651,8 @@ pub type Migrations = (
 	// permanent
 	pallet_xcm::migration::MigrateToLatestXcmVersion<Runtime>,
 	cumulus_pallet_aura_ext::migration::MigrateV0ToV1<Runtime>,
+	// unreleased
+	pallet_dap::migrations::MigrateV1ToV2<Runtime, DapLastIssuanceTimestamp, DefaultDapBudget>,
 );
 
 /// Asset Hub Westend has some undecodable storage, delete it.
@@ -2899,6 +2932,19 @@ fn ensure_key_ss58() {
 	assert_eq!(acc, RootMigController::sorted_members()[0]);
 }
 
+#[test]
+fn issuance_cadence_smaller_than_era_length() {
+	use crate::staking::{RelaySessionDuration, SessionsPerEra};
+	let era_length_ms = SessionsPerEra::get() as u64 *
+		RelaySessionDuration::get() as u64 *
+		RELAY_CHAIN_SLOT_DURATION_MILLIS as u64;
+	let cadence = <Runtime as pallet_dap::Config>::IssuanceCadence::get();
+	assert!(
+		cadence < era_length_ms,
+		"IssuanceCadence ({cadence}ms) must be smaller than era length ({era_length_ms}ms)"
+	);
+}
+
 #[test]
 fn ensure_epmb_weights_sane() {
 	use sp_io::TestExternalities;

cumulus/parachains/runtimes/assets/asset-hub-westend/src/staking.rs

@@ -228,29 +228,20 @@ impl pallet_bags_list::Config<VoterBagsListInstance> for Runtime {
 	type WeightInfo = weights::pallet_bags_list::WeightInfo<Runtime>;
 }
 
-pub struct EraPayout;
-impl pallet_staking_async::EraPayout<Balance> for EraPayout {
-	fn era_payout(
-		_total_staked: Balance,
-		_total_issuance: Balance,
-		era_duration_millis: u64,
-	) -> (Balance, Balance) {
+pub struct PolkadotIssuanceCurve;
+impl sp_staking::budget::IssuanceCurve<Balance> for PolkadotIssuanceCurve {
+	fn issue(_total_issuance: Balance, elapsed_millis: u64) -> Balance {
 		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());
+		let relative_period =
+			FixedU128::from_rational(elapsed_millis.into(), MILLISECONDS_PER_YEAR.into());
 
 		// Fixed total TI that we use as baseline for the issuance.
 		let fixed_total_issuance: i128 = 5_216_342_402_773_185_773;
 		let fixed_inflation_rate = FixedU128::from_rational(8, 100);
 		let yearly_emission = fixed_inflation_rate.saturating_mul_int(fixed_total_issuance);
 
-		let era_emission = relative_era_len.saturating_mul_int(yearly_emission);
-		// 15% to treasury, as per Polkadot 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())
+		let period_emission = relative_period.saturating_mul_int(yearly_emission);
+		period_emission.saturated_into()
 	}
 }
 
@@ -268,8 +259,8 @@ parameter_types! {
 	pub const MaxControllersInDeprecationBatch: u32 = 751;
 	// alias for 16, which is the max nominations per nominator in the runtime.
 	pub const MaxNominations: u32 = <NposCompactSolution16 as frame_election_provider_support::NposSolution>::LIMIT as u32;
-	pub const MaxEraDuration: u64 = RelaySessionDuration::get() as u64 * RELAY_CHAIN_SLOT_DURATION_MILLIS as u64 * SessionsPerEra::get() as u64;
 	pub MaxPruningItems: u32 = 100;
+	pub const StakingPalletId: PalletId = PalletId(*b"py/stkng");
 }
 
 impl pallet_staking_async::Config for Runtime {
@@ -281,13 +272,15 @@ impl pallet_staking_async::Config for Runtime {
 	type CurrencyToVote = sp_staking::currency_to_vote::SaturatingCurrencyToVote;
 	type RewardRemainder = Dap;
 	type Slash = Dap;
+	type UnclaimedRewardHandler = Dap;
 	type Reward = ();
+	type GeneralPots = pallet_staking_async::Seed<StakingPalletId>;
+	type EraPots = pallet_staking_async::Seed<StakingPalletId>;
 	type SessionsPerEra = SessionsPerEra;
 	type BondingDuration = BondingDuration;
 	type NominatorFastUnbondDuration = NominatorFastUnbondDuration;
 	type SlashDeferDuration = SlashDeferDuration;
 	type AdminOrigin = EitherOf<EnsureRoot<AccountId>, StakingAdmin>;
-	type EraPayout = EraPayout;
 	type MaxExposurePageSize = MaxExposurePageSize;
 	type ElectionProvider = MultiBlockElection;
 	type VoterList = VoterList;
@@ -300,8 +293,15 @@ impl pallet_staking_async::Config for Runtime {
 	type EventListeners = (NominationPools, DelegatedStaking);
 	type PlanningEraOffset = ConstU32<6>;
 	type RcClientInterface = StakingRcClient;
-	type MaxEraDuration = MaxEraDuration;
 	type MaxPruningItems = MaxPruningItems;
+	type StakerRewardCalculator =
+		pallet_staking_async::reward::DefaultStakerRewardCalculator<Runtime>;
+	/// Vest validator incentive rewards over 2 days (in relay chain blocks).
+	type VestingDuration = ConstU32<{ 2 * RC_DAYS }>;
+	/// Relay chain session length in RC blocks (1 hour on Westend).
+	type BlocksPerSession = ConstU32<RC_HOURS>;
+	type ValidatorIncentivePayout =
+		pallet_staking_async::VestedIncentivePayout<pallet_vesting::Pallet<Runtime>>;
 	type WeightInfo = weights::pallet_staking_async::WeightInfo<Runtime>;
 }
 
@@ -344,22 +344,30 @@ impl pallet_staking_async_rc_client::Config for Runtime {
 
 parameter_types! {
 	pub const DapPalletId: frame_support::PalletId = frame_support::PalletId(*b"dap/buff");
-	/// Minimum time (ms) between issuance drips. 60s = drip at most once per minute.
+	/// Drip inflation every 60 seconds. Must be smaller than era length.
+	/// When adding DAP to other runtimes, copy the `issuance_cadence_smaller_than_era_length`
+	/// test from this runtime.
 	pub const IssuanceCadence: u64 = 60_000;
-	/// Safety ceiling (ms) for elapsed time in a single drip. Prevents over-minting after stalls.
+	/// Safety ceiling on elapsed time per drip: 10 minutes.
+	/// Prevents over-minting if blocks are delayed or chain stalls.
 	pub const MaxElapsedPerDrip: u64 = 600_000;
 }
 
 impl pallet_dap::Config for Runtime {
 	type Currency = Balances;
 	type PalletId = DapPalletId;
-	/// Noop — DAP does not mint until budget drip is enabled.
-	type IssuanceCurve = ();
-	type BudgetRecipients = (pallet_dap::Pallet<Runtime>,);
-	type Time = pallet_timestamp::Pallet<Runtime>;
+	type IssuanceCurve = PolkadotIssuanceCurve;
+	type BudgetRecipients = (
+		Dap,
+		pallet_staking_async::StakerRewardRecipient<pallet_staking_async::Seed<StakingPalletId>>,
+		pallet_staking_async::ValidatorIncentiveRecipient<
+			pallet_staking_async::Seed<StakingPalletId>,
+		>,
+	);
+	type Time = Timestamp;
 	type IssuanceCadence = IssuanceCadence;
 	type MaxElapsedPerDrip = MaxElapsedPerDrip;
-	type BudgetOrigin = frame_system::EnsureRoot<AccountId>;
+	type BudgetOrigin = EnsureRoot<AccountId>;
 	type WeightInfo = ();
 }
 

cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/pallet_staking_async.rs

@@ -721,6 +721,14 @@ impl<T: frame_system::Config> pallet_staking_async::WeightInfo for WeightInfo<T>
 			.saturating_add(Weight::from_parts(0, 0))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
+	fn set_max_commission() -> Weight {
+		// TODO(ank4n): Run benchmarks
+		todo!()
+	}
+	fn set_validator_self_stake_incentive_config() -> Weight {
+		// TODO(ank4n): Run benchmarks
+		todo!()
+	}
 	/// Storage: `System::Account` (r:1 w:0)
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::VirtualStakers` (r:1 w:0)

polkadot/runtime/westend/src/lib.rs

@@ -709,7 +709,7 @@ impl pallet_bags_list::Config<VoterBagsListInstance> for Runtime {
 }
 
 pub struct EraPayout;
-impl pallet_staking::EraPayout<Balance> for EraPayout {
+impl sp_staking::EraPayout<Balance> for EraPayout {
 	fn era_payout(
 		_total_staked: Balance,
 		_total_issuance: Balance,

polkadot/runtime/westend/src/tests.rs

@@ -27,10 +27,10 @@ use frame_support::{
 		WhitelistedStorageKeys,
 	},
 };
-use pallet_staking::EraPayout;
 use sp_core::{crypto::Ss58Codec, hexdisplay::HexDisplay};
 use sp_keyring::Sr25519Keyring::{self, Alice};
 use sp_runtime::generic::Era;
+use sp_staking::EraPayout;
 use xcm_runtime_apis::conversions::LocationToAccountHelper;
 
 const MILLISECONDS_PER_HOUR: u64 = 60 * 60 * 1000;

prdoc/pr_10844.prdoc

@@ -0,0 +1,52 @@
+title: "Move era reward minting to DAP with era-based allocation in Staking"
+doc:
+- audience: Runtime Dev
+  description: |-
+    Rewires staking reward minting by introducing DAP as the central inflation engine.
+
+    **DAP (`pallet-dap`)**: Becomes a generic inflation drip and distribution engine. Inflation
+    is minted per-block (configurable cadence) via `InflationCurve` and distributed across
+    registered `BudgetRecipient` implementors through a governance-updatable `BudgetAllocation`
+    map. New budget categories can be added without changing DAP code.
+
+    **Staking (`pallet-staking-async`)**: At era boundaries, staking snapshots accumulated
+    reward pots (filled continuously by DAP) into era-specific accounts. Adds a validator
+    self-stake incentive: a sqrt-based weight function rewards validators for increasing their
+    own stake with governance-configurable thresholds (`OptimumSelfStake`, `HardCapSelfStake`,
+    `SelfStakeSlopeFactor`). Payouts can be immediate or vested via `ValidatorIncentivePayout`.
+
+    **Incentive vesting batch conversion**: To avoid exhausting `MaxVestingSchedules` (typically
+    28), validator incentive rewards are accumulated under a `HoldReason::IncentiveVesting` hold
+    and batch-converted to a vesting schedule every `BondingDuration` eras. At conversion, a
+    retroactive unlock fraction (`BondingDuration / vesting_eras`) is released as liquid,
+    and the remainder is vested over the remaining duration, where
+    `vesting_eras = VestingDuration / (BlocksPerSession * SessionsPerEra)`. New config type
+    `BlocksPerSession` (in relay chain blocks) is required alongside `VestingDuration`.
+
+    **Primitives (`sp-staking`)**: New traits -- `InflationCurve`, `BudgetRecipient`,
+    `UnclaimedRewardSink`, `StakerRewardCalculator`.
+
+crates:
+- name: pallet-dap
+  bump: major
+- name: pallet-staking-async
+  bump: major
+- name: sp-staking
+  bump: major
+- name: pallet-nomination-pools
+  bump: patch
+- name: pallet-nomination-pools-benchmarking
+  bump: patch
+- name: pallet-nomination-pools-test-delegate-stake
+  bump: patch
+  validate: false
+- name: frame-support
+  bump: minor
+- name: pallet-staking
+  bump: patch
+- name: pallet-vesting
+  bump: minor
+- name: westend-runtime
+  bump: patch
+- name: asset-hub-westend-runtime
+  bump: patch

substrate/frame/dap/src/lib.rs

@@ -82,7 +82,7 @@ pub mod pallet {
 	use frame_system::pallet_prelude::*;
 
 	/// The in-code storage version.
-	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(2);
 
 	#[pallet::pallet]
 	#[pallet::storage_version(STORAGE_VERSION)]

substrate/frame/nomination-pools/test-delegate-stake/src/mock.rs

@@ -91,19 +91,6 @@ pallet_staking_reward_curve::build! {
 parameter_types! {
 	pub const RewardCurve: &'static sp_runtime::curve::PiecewiseLinear<'static> = &I_NPOS;
 	pub static BondingDuration: u32 = 3;
-	pub static EraPayout: (Balance, Balance) = (1000, 100);
-}
-
-/// A simple EraPayout implementation for testing that returns fixed values.
-pub struct TestEraPayout;
-impl pallet_staking_async::EraPayout<Balance> for TestEraPayout {
-	fn era_payout(
-		_total_staked: Balance,
-		_total_issuance: Balance,
-		_era_duration_millis: u64,
-	) -> (Balance, Balance) {
-		EraPayout::get()
-	}
 }
 
 /// A mock RcClientInterface for tests that don't need actual session/validator set management.
@@ -126,13 +113,17 @@ impl pallet_staking_async::Config for Runtime {
 	type Currency = Balances;
 	type AdminOrigin = frame_system::EnsureRoot<Self::AccountId>;
 	type BondingDuration = BondingDuration;
-	type EraPayout = TestEraPayout;
 	type ElectionProvider =
 		frame_election_provider_support::NoElection<(AccountId, BlockNumber, Staking, (), ())>;
 	type VoterList = VoterList;
 	type TargetList = pallet_staking_async::UseValidatorsMap<Self>;
 	type EventListeners = (Pools, DelegatedStaking);
 	type RcClientInterface = MockRcClient;
+	type VestingDuration = ConstU64<0>;
+	type BlocksPerSession = ConstU64<1>;
+	type ValidatorIncentivePayout = pallet_staking_async::ImmediateIncentivePayout<Balances>;
+	type StakerRewardCalculator =
+		pallet_staking_async::reward::DefaultStakerRewardCalculator<Runtime>;
 }
 
 parameter_types! {

substrate/frame/staking-async/Cargo.toml

@@ -26,6 +26,7 @@ rand_chacha = { workspace = true }
 scale-info = { features = ["derive", "serde"], workspace = true }
 serde = { features = ["alloc", "derive"], workspace = true }
 sp-application-crypto = { features = ["serde"], workspace = true }
+sp-arithmetic = { workspace = true }
 sp-core = { workspace = true }
 sp-io = { workspace = true }
 sp-npos-elections = { workspace = true }
@@ -42,6 +43,7 @@ frame-benchmarking = { workspace = true, default-features = true }
 frame-support = { features = ["experimental"], workspace = true, default-features = true }
 pallet-bags-list = { workspace = true, default-features = true }
 pallet-balances = { workspace = true, default-features = true }
+pallet-dap = { workspace = true, default-features = true }
 rand_chacha = { workspace = true, default-features = true }
 sp-tracing = { workspace = true, default-features = true }
 substrate-test-utils = { workspace = true }
@@ -64,6 +66,7 @@ std = [
 	"scale-info/std",
 	"serde/std",
 	"sp-application-crypto/std",
+	"sp-arithmetic/std",
 	"sp-core/std",
 	"sp-core/std",
 	"sp-io/std",
@@ -79,6 +82,7 @@ runtime-benchmarks = [
 	"frame-system/runtime-benchmarks",
 	"pallet-bags-list/runtime-benchmarks",
 	"pallet-balances/runtime-benchmarks",
+	"pallet-dap/runtime-benchmarks",
 	"pallet-staking-async-rc-client/runtime-benchmarks",
 	"sp-runtime/runtime-benchmarks",
 	"sp-staking/runtime-benchmarks",
@@ -89,6 +93,7 @@ try-runtime = [
 	"frame-system/try-runtime",
 	"pallet-bags-list/try-runtime",
 	"pallet-balances/try-runtime",
+	"pallet-dap/try-runtime",
 	"pallet-staking-async-rc-client/try-runtime",
 	"sp-runtime/try-runtime",
 ]