frame-support: add FundingSource and FundingSink traits

- FundingSource: trait for requesting funds from an issuance system
  - this could mean minting new tokens or transferring from a given
    issuance buffer's account
- FundingSink: trait for returning funds to an issuance system
  - this could mean burning tokens or transferring to a given
    issuance buffer's account

Author: sigurpol

substrate/frame/support/src/traits/tokens.rs

@@ -19,6 +19,7 @@
 
 pub mod asset_ops;
 pub mod currency;
+pub mod funding;
 pub mod fungible;
 pub mod fungibles;
 pub mod imbalance;
@@ -27,6 +28,7 @@ pub mod nonfungible;
 pub mod nonfungible_v2;
 pub mod nonfungibles;
 pub mod nonfungibles_v2;
+pub use funding::{DirectBurn, DirectMint, FundingSink, FundingSource};
 pub use imbalance::Imbalance;
 pub mod pay;
 pub mod transfer;

substrate/frame/support/src/traits/tokens/funding.rs

@@ -0,0 +1,105 @@
+// 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.
+
+//! Traits for funding sources and sinks in token issuance systems.
+//!
+//! This module provides abstractions for pulling funds (rewards, payments) and returning funds
+//! (burns, slashing) in a way that can be configured differently per runtime.
+//!
+//! Two main patterns:
+//! - **Direct mint/burn**: Traditional approach where funds are created/destroyed on demand
+//! - **Buffer-based**: Funds are pre-minted into a buffer and distributed from there
+
+use crate::traits::tokens::{fungible, Fortitude, Precision, Preservation};
+use core::marker::PhantomData;
+use sp_runtime::{DispatchError, DispatchResult};
+
+/// Trait for requesting funds from an issuance system.
+///
+/// Implementations can either mint directly or pull from a pre-minted buffer.
+pub trait FundingSource<AccountId, Balance> {
+	/// Request funds to be transferred to the beneficiary.
+	///
+	/// Returns the actual amount transferred, which may be less than requested
+	/// if the source has insufficient funds.
+	fn request_funds(beneficiary: &AccountId, amount: Balance) -> Result<Balance, DispatchError>;
+}
+
+/// Trait for returning funds to an issuance system.
+///
+/// Implementations can either burn directly or return to a buffer for reuse.
+pub trait FundingSink<AccountId, Balance> {
+	/// Return funds from the given account back to the issuance system.
+	///
+	/// This could mean burning the funds or transferring them to a buffer account.
+	fn return_funds(from: &AccountId, amount: Balance) -> DispatchResult;
+}
+
+/// Direct minting implementation of `FundingSource`.
+///
+/// This implementation mints tokens directly when funds are requested.
+/// Used for traditional mint-on-demand systems (e.g., Kusama).
+///
+/// # Type Parameters
+///
+/// * `Currency` - The currency type that implements `Mutate`
+/// * `AccountId` - The account identifier type
+pub struct DirectMint<Currency, AccountId>(PhantomData<(Currency, AccountId)>);
+
+impl<Currency, AccountId> FundingSource<AccountId, Currency::Balance>
+	for DirectMint<Currency, AccountId>
+where
+	Currency: fungible::Mutate<AccountId>,
+	AccountId: Eq,
+{
+	fn request_funds(
+		beneficiary: &AccountId,
+		amount: Currency::Balance,
+	) -> Result<Currency::Balance, DispatchError> {
+		Currency::mint_into(beneficiary, amount)?;
+		Ok(amount)
+	}
+}
+
+/// Direct burning implementation of `FundingSink`.
+///
+/// This implementation burns tokens directly when funds are returned.
+/// Used for traditional burn-on-return systems (e.g., Kusama).
+///
+/// # Type Parameters
+///
+/// * `Currency` - The currency type that implements `Mutate`
+/// * `AccountId` - The account identifier type
+pub struct DirectBurn<Currency, AccountId>(PhantomData<(Currency, AccountId)>);
+
+impl<Currency, AccountId> FundingSink<AccountId, Currency::Balance>
+	for DirectBurn<Currency, AccountId>
+where
+	Currency: fungible::Mutate<AccountId>,
+	AccountId: Eq,
+{
+	fn return_funds(from: &AccountId, amount: Currency::Balance) -> DispatchResult {
+		Currency::burn_from(
+			from,
+			amount,
+			Preservation::Expendable,
+			Precision::Exact,
+			Fortitude::Polite,
+		)?;
+		Ok(())
+	}
+}