Implement Budget Distribution logic in pallet-dap

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

@@ -344,11 +344,23 @@ 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.
+	pub const IssuanceCadence: u64 = 60_000;
+	/// Safety ceiling (ms) for elapsed time in a single drip. Prevents over-minting after 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 IssuanceCadence = IssuanceCadence;
+	type MaxElapsedPerDrip = MaxElapsedPerDrip;
+	type BudgetOrigin = frame_system::EnsureRoot<AccountId>;
+	type WeightInfo = ();
 }
 
 #[derive(Encode, Decode)]

cumulus/parachains/runtimes/assets/asset-hub-westend/tests/tests.rs

@@ -2526,7 +2526,9 @@ mod dap {
 	#[test]
 	fn tx_fees_go_to_dap_buffer() {
 		let alice = AccountId::from(Sr25519Keyring::Alice);
-		let buffer = pallet_dap::Pallet::<Runtime>::buffer_account();
+		let buffer = <pallet_dap::Pallet<Runtime> as sp_staking::budget::BudgetRecipient<
+			AccountId,
+		>>::pot_account();
 		let ed = ExistentialDeposit::get();
 
 		ExtBuilder::<Runtime>::default()
@@ -2564,7 +2566,9 @@ mod dap {
 	fn dust_removal_goes_to_dap_buffer() {
 		let alice = AccountId::from(ALICE);
 		let bob = AccountId::from(BOB);
-		let buffer = pallet_dap::Pallet::<Runtime>::buffer_account();
+		let buffer = <pallet_dap::Pallet<Runtime> as sp_staking::budget::BudgetRecipient<
+			AccountId,
+		>>::pot_account();
 		let ed = ExistentialDeposit::get();
 		let dust = ed / 2;
 

prdoc/pr_11527.prdoc

@@ -0,0 +1,24 @@
+title: Add issuance drip and budget distribution to pallet-dap
+doc:
+- audience: Runtime Dev
+  description: |-
+    Adds issuance drip and budget distribution to `pallet-dap`. DAP mints new tokens on a
+    configurable cadence via `IssuanceCurve` and distributes them to registered
+    `BudgetRecipient`s according to a governance-updatable allocation map.
+
+    Includes `set_budget_allocation` extrinsic, `OnUnbalanced` slash handling with buffer
+    deactivation, safety ceiling on elapsed time, and a V1→V2 migration struct (not yet applied).
+
+    All runtimes are configured with a noop `IssuanceCurve` (`()` impl that returns 0) so there
+    is no behavior change. Minting will be enabled when staking is integrated with DAP.
+crates:
+- name: pallet-dap
+  bump: major
+- name: sp-staking
+  bump: minor
+- name: asset-hub-westend-runtime
+  bump: major
+- name: pallet-staking-async-parachain-runtime
+  bump: patch
+- name: pallet-ahm-test
+  bump: patch

substrate/frame/dap/Cargo.toml

@@ -22,6 +22,7 @@ frame-system = { workspace = true }
 log = { workspace = true }
 scale-info = { features = ["derive"], workspace = true }
 sp-runtime = { workspace = true }
+sp-staking = { workspace = true }
 
 [dev-dependencies]
 pallet-balances = { workspace = true, default-features = true }
@@ -40,13 +41,15 @@ std = [
 	"sp-core/std",
 	"sp-io/std",
 	"sp-runtime/std",
+	"sp-staking/std",
 ]
 runtime-benchmarks = [
 	"frame-benchmarking/runtime-benchmarks",
 	"frame-support/runtime-benchmarks",
 	"frame-system/runtime-benchmarks",
 	"pallet-balances/runtime-benchmarks",
 	"sp-runtime/runtime-benchmarks",
+	"sp-staking/runtime-benchmarks",
 ]
 try-runtime = [
 	"frame-support/try-runtime",

substrate/frame/dap/src/benchmarking.rs

@@ -0,0 +1,78 @@
+// This file is part of Substrate.
+
+// Copyright (C) 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.
+
+//! Benchmarks for pallet-dap.
+
+use super::*;
+use frame_benchmarking::v2::*;
+use frame_support::traits::Time;
+use frame_system::RawOrigin;
+use sp_staking::budget::BudgetRecipientList;
+
+#[benchmarks]
+mod benchmarks {
+	use super::*;
+
+	/// Build a valid allocation from registered recipients, distributing evenly and giving
+	/// the remainder to the last recipient to ensure the sum is exactly 100%.
+	fn build_even_allocation<T: Config>() -> BudgetAllocationMap {
+		let recipients = T::BudgetRecipients::recipients();
+		let count = recipients.len() as u32;
+		let mut allocations = BudgetAllocationMap::new();
+
+		for (i, (key, _)) in recipients.into_iter().enumerate() {
+			let perbill = if i as u32 == count - 1 {
+				let used: u32 = allocations.values().map(|p| p.deconstruct()).sum();
+				Perbill::from_parts(Perbill::one().deconstruct().saturating_sub(used))
+			} else {
+				Perbill::from_rational(1u32, count)
+			};
+			allocations.try_insert(key, perbill).expect("bounded by MAX_BUDGET_RECIPIENTS");
+		}
+
+		allocations
+	}
+
+	#[benchmark]
+	fn set_budget_allocation() {
+		let allocations = build_even_allocation::<T>();
+
+		#[extrinsic_call]
+		_(RawOrigin::Root, allocations.clone());
+
+		assert_eq!(BudgetAllocation::<T>::get(), allocations);
+	}
+
+	#[benchmark]
+	fn drip_issuance() {
+		let allocations = build_even_allocation::<T>();
+		BudgetAllocation::<T>::put(allocations);
+
+		// Seed the timestamp so the drip fires.
+		let now: u64 = T::Time::now().saturated_into();
+		let past = now.saturating_sub(T::IssuanceCadence::get() + 1);
+		LastIssuanceTimestamp::<T>::put(past);
+
+		#[block]
+		{
+			Pallet::<T>::drip_issuance();
+		}
+
+		// Timestamp should be updated.
+		assert!(LastIssuanceTimestamp::<T>::get() > past);
+	}
+}