Pallets: Treasury spend() should use Pay trait

bin/node/runtime/src/lib.rs

@@ -35,7 +35,7 @@ use frame_support::{
 	parameter_types,
 	traits::{
 		fungible::ItemOf,
-		tokens::{nonfungibles_v2::Inspect, GetSalary, PayFromAccount},
+		tokens::{nonfungibles_v2::Inspect, GetSalary, PayFromAccount, PayFungibles},
 		AsEnsureOriginWithArg, ConstBool, ConstU128, ConstU16, ConstU32, Currency, EitherOfDiverse,
 		EqualPrivilegeOnly, Everything, Imbalance, InstanceFilter, KeyOwnerProofSystem,
 		LockIdentifier, Nothing, OnUnbalanced, U128CurrencyToVote, WithdrawReasons,
@@ -1106,6 +1106,10 @@ parameter_types! {
 
 impl pallet_treasury::Config for Runtime {
 	type PalletId = TreasuryPalletId;
+	type AssetId = u32;
+	type AssetKind = pallet_treasury::SimpleAsset<u32, u128>;
+	type Paymaster = PayFungibles<Assets, TreasuryAccount>;
+	type BalanceConverter = ();
 	type Currency = Balances;
 	type ApproveOrigin = EitherOfDiverse<
 		EnsureRoot<AccountId>,
@@ -1127,6 +1131,9 @@ impl pallet_treasury::Config for Runtime {
 	type WeightInfo = pallet_treasury::weights::SubstrateWeight<Runtime>;
 	type MaxApprovals = MaxApprovals;
 	type SpendOrigin = EnsureWithSuccess<EnsureRoot<AccountId>, AccountId, MaxBalance>;
+	type MaxPaymentRetries = ConstU32<3>;
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkHelper = ();
 }
 
 impl pallet_asset_rate::Config for Runtime {

frame/bounties/src/tests.rs

@@ -26,7 +26,7 @@ use frame_support::{
 	assert_noop, assert_ok,
 	pallet_prelude::GenesisBuild,
 	parameter_types,
-	traits::{ConstU32, ConstU64, OnInitialize},
+	traits::{tokens::PayFromAccount, ConstU32, ConstU64, OnInitialize},
 	PalletId,
 };
 
@@ -59,6 +59,8 @@ frame_support::construct_runtime!(
 
 parameter_types! {
 	pub const AvailableBlockRatio: Perbill = Perbill::one();
+	pub TreasuryAccount: u128 = Treasury::account_id();
+	pub TreasuryAccount1: u128 = Treasury1::account_id();
 }
 
 type Balance = u64;
@@ -114,8 +116,19 @@ parameter_types! {
 	pub static SpendLimit1: Balance = u64::MAX;
 }
 
+pub struct NilBenchmarkHelper;
+#[cfg(feature = "runtime-benchmarks")]
+impl<AssetKind: From<()>> pallet_treasury::BenchmarkHelper<AssetKind> for NilBenchmarkHelper {
+	fn create_asset_kind(_id: u32) -> AssetKind {
+		().into()
+	}
+}
+
 impl pallet_treasury::Config for Test {
 	type PalletId = TreasuryPalletId;
+	type AssetKind = ();
+	type Paymaster = PayFromAccount<Balances, TreasuryAccount>;
+	type BalanceConverter = ();
 	type Currency = pallet_balances::Pallet<Test>;
 	type ApproveOrigin = frame_system::EnsureRoot<u128>;
 	type RejectOrigin = frame_system::EnsureRoot<u128>;
@@ -131,10 +144,15 @@ impl pallet_treasury::Config for Test {
 	type SpendFunds = Bounties;
 	type MaxApprovals = ConstU32<100>;
 	type SpendOrigin = frame_system::EnsureRootWithSuccess<Self::AccountId, SpendLimit>;
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkHelper = NilBenchmarkHelper;
 }
 
 impl pallet_treasury::Config<Instance1> for Test {
 	type PalletId = TreasuryPalletId2;
+	type AssetKind = ();
+	type Paymaster = PayFromAccount<Balances, TreasuryAccount1>;
+	type BalanceConverter = ();
 	type Currency = pallet_balances::Pallet<Test>;
 	type ApproveOrigin = frame_system::EnsureRoot<u128>;
 	type RejectOrigin = frame_system::EnsureRoot<u128>;
@@ -150,6 +168,8 @@ impl pallet_treasury::Config<Instance1> for Test {
 	type SpendFunds = Bounties1;
 	type MaxApprovals = ConstU32<100>;
 	type SpendOrigin = frame_system::EnsureRootWithSuccess<Self::AccountId, SpendLimit1>;
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkHelper = NilBenchmarkHelper;
 }
 
 parameter_types! {

frame/child-bounties/src/tests.rs

@@ -26,11 +26,10 @@ use frame_support::{
 	assert_noop, assert_ok,
 	pallet_prelude::GenesisBuild,
 	parameter_types,
-	traits::{ConstU32, ConstU64, OnInitialize},
+	traits::{tokens::PayFromAccount, ConstU32, ConstU64, OnInitialize},
 	weights::Weight,
 	PalletId,
 };
-
 use sp_core::H256;
 use sp_runtime::{
 	testing::Header,
@@ -113,10 +112,15 @@ parameter_types! {
 	pub const Burn: Permill = Permill::from_percent(50);
 	pub const TreasuryPalletId: PalletId = PalletId(*b"py/trsry");
 	pub const SpendLimit: Balance = u64::MAX;
+	pub TreasuryAccount: u128 = Treasury::account_id();
 }
 
 impl pallet_treasury::Config for Test {
 	type PalletId = TreasuryPalletId;
+	type AssetId = ();
+	type AssetKind = u64;
+	type Paymaster = PayFromAccount<Balances, TreasuryAccount>;
+	type BalanceConverter = ();
 	type Currency = pallet_balances::Pallet<Test>;
 	type ApproveOrigin = frame_system::EnsureRoot<u128>;
 	type RejectOrigin = frame_system::EnsureRoot<u128>;
@@ -132,6 +136,9 @@ impl pallet_treasury::Config for Test {
 	type SpendFunds = Bounties;
 	type MaxApprovals = ConstU32<100>;
 	type SpendOrigin = frame_system::EnsureRootWithSuccess<Self::AccountId, SpendLimit>;
+	type MaxPaymentRetries = ConstU32<3>;
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkHelper = pallet_treasury::NilBenchmarkHelper;
 }
 parameter_types! {
 	// This will be 50% of the bounty fee.

frame/support/src/traits/dispatch.rs

@@ -163,7 +163,9 @@ pub trait EnsureOriginWithArg<OuterOrigin, Argument> {
 	///
 	/// ** Should be used for benchmarking only!!! **
 	#[cfg(feature = "runtime-benchmarks")]
-	fn try_successful_origin(a: &Argument) -> Result<OuterOrigin, ()>;
+	fn try_successful_origin(a: &Argument) -> Result<OuterOrigin, ()>{
+        Err(())
+    }
 }
 
 pub struct AsEnsureOriginWithArg<EO>(sp_std::marker::PhantomData<EO>);

frame/support/src/traits/tokens.rs

@@ -33,4 +33,4 @@ pub use misc::{
 	ConvertRank, DepositConsequence, ExistenceRequirement, Fortitude, GetSalary, Locker, Precision,
 	Preservation, Provenance, Restriction, WithdrawConsequence, WithdrawReasons,
 };
-pub use pay::{Pay, PayFromAccount, PaymentStatus};
+pub use pay::{Pay, PayFromAccount, PayFungibles, PaymentStatus};

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

@@ -262,6 +262,18 @@ pub trait ConversionFromAssetBalance<AssetBalance, AssetId, OutBalance> {
 	) -> Result<OutBalance, Self::Error>;
 }
 
+impl<InBalance, AssetId, OutBalance: core::convert::From<InBalance>>
+	ConversionFromAssetBalance<InBalance, AssetId, OutBalance> for ()
+{
+	type Error = ();
+	fn from_asset_balance(
+		balance: InBalance,
+		_asset_id: AssetId,
+	) -> Result<OutBalance, Self::Error> {
+		Ok(balance.into())
+	}
+}
+
 /// Trait to handle NFT locking mechanism to ensure interactions with the asset can be implemented
 /// downstream to extend logic of Uniques/Nfts current functionality.
 pub trait Locker<CollectionId, ItemId> {

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

@@ -23,7 +23,7 @@ use sp_core::{RuntimeDebug, TypedGet};
 use sp_runtime::DispatchError;
 use sp_std::fmt::Debug;
 
-use super::{fungible, Balance, Preservation::Expendable};
+use super::{fungible, fungibles, Balance, Preservation::Expendable};
 
 /// Can be implemented by `PayFromAccount` using a `fungible` impl, but can also be implemented with
 /// XCM/MultiAsset and made generic over assets.
@@ -107,3 +107,29 @@ impl<A: TypedGet, F: fungible::Mutate<A::Type>> Pay for PayFromAccount<F, A> {
 	#[cfg(feature = "runtime-benchmarks")]
 	fn ensure_concluded(_: Self::Id) {}
 }
+
+pub struct PayFungibles<F, A>(sp_std::marker::PhantomData<(F, A)>);
+impl<A: TypedGet, F: fungibles::Mutate<A::Type> + fungibles::Inspect<A::Type>> Pay
+	for PayFungibles<F, A>
+{
+	type Balance = F::Balance;
+	type Beneficiary = A::Type;
+	type AssetKind = F::AssetId;
+	type Id = ();
+	type Error = DispatchError;
+	fn pay(
+		who: &Self::Beneficiary,
+		asset_id: Self::AssetKind,
+		amount: Self::Balance,
+	) -> Result<Self::Id, Self::Error> {
+		<F as fungibles::Mutate<_>>::transfer(asset_id, &A::get(), who, amount, Expendable)?;
+		Ok(())
+	}
+	fn check_payment(_: ()) -> PaymentStatus {
+		PaymentStatus::Success
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn ensure_successful(_: &Self::Beneficiary, _: Self::Balance) {}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn ensure_concluded(_: Self::Id) {}
+}

frame/tips/src/tests.rs

@@ -32,7 +32,7 @@ use frame_support::{
 	pallet_prelude::GenesisBuild,
 	parameter_types,
 	storage::StoragePrefixedMap,
-	traits::{ConstU32, ConstU64, SortedMembers, StorageVersion},
+	traits::{tokens::PayFromAccount, ConstU32, ConstU64, SortedMembers, StorageVersion},
 	PalletId,
 };
 
@@ -59,6 +59,8 @@ frame_support::construct_runtime!(
 
 parameter_types! {
 	pub const AvailableBlockRatio: Perbill = Perbill::one();
+	pub TreasuryAccount: u128 = Treasury::account_id();
+	pub TreasuryAccount1: u128 = Treasury1::account_id();
 }
 impl frame_system::Config for Test {
 	type BaseCallFilter = frame_support::traits::Everything;
@@ -132,8 +134,13 @@ parameter_types! {
 	pub const TreasuryPalletId: PalletId = PalletId(*b"py/trsry");
 	pub const TreasuryPalletId2: PalletId = PalletId(*b"py/trsr2");
 }
+
 impl pallet_treasury::Config for Test {
 	type PalletId = TreasuryPalletId;
+	type AssetId = ();
+	type AssetKind = u64;
+	type Paymaster = PayFromAccount<Balances, TreasuryAccount>;
+	type BalanceConverter = ();
 	type Currency = pallet_balances::Pallet<Test>;
 	type ApproveOrigin = frame_system::EnsureRoot<u128>;
 	type RejectOrigin = frame_system::EnsureRoot<u128>;
@@ -149,10 +156,17 @@ impl pallet_treasury::Config for Test {
 	type SpendFunds = ();
 	type MaxApprovals = ConstU32<100>;
 	type SpendOrigin = frame_support::traits::NeverEnsureOrigin<u64>;
+	type MaxPaymentRetries = ConstU32<3>;
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkHelper = pallet_treasury::NilBenchmarkHelper;
 }
 
 impl pallet_treasury::Config<Instance1> for Test {
 	type PalletId = TreasuryPalletId2;
+	type AssetId = ();
+	type AssetKind = u64;
+	type Paymaster = PayFromAccount<Balances, TreasuryAccount1>;
+	type BalanceConverter = ();
 	type Currency = pallet_balances::Pallet<Test>;
 	type ApproveOrigin = frame_system::EnsureRoot<u128>;
 	type RejectOrigin = frame_system::EnsureRoot<u128>;
@@ -168,6 +182,9 @@ impl pallet_treasury::Config<Instance1> for Test {
 	type SpendFunds = ();
 	type MaxApprovals = ConstU32<100>;
 	type SpendOrigin = frame_support::traits::NeverEnsureOrigin<u64>;
+	type MaxPaymentRetries = ConstU32<3>;
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkHelper = pallet_treasury::NilBenchmarkHelper;
 }
 
 parameter_types! {

frame/treasury/Cargo.toml

@@ -24,6 +24,7 @@ frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional
 frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
 frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
 pallet-balances = { version = "4.0.0-dev", default-features = false, path = "../balances" }
+pallet-assets = { version = "4.0.0-dev", default-features = false, path = "../assets" }
 sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
 sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
 
@@ -40,6 +41,7 @@ std = [
 	"frame-support/std",
 	"frame-system/std",
 	"pallet-balances/std",
+	"pallet-assets/std",
 	"scale-info/std",
 	"serde",
 	"sp-runtime/std",

frame/treasury/src/benchmarking.rs

@@ -31,6 +31,10 @@ use frame_system::RawOrigin;
 
 const SEED: u32 = 0;
 
+fn default_asset_kind<T: Config<I>, I: 'static>() -> T::AssetKind {
+	T::BenchmarkHelper::create_asset_kind(0)
+}
+
 // Create the pre-requisite information needed to create a treasury `propose_spend`.
 fn setup_proposal<T: Config<I>, I: 'static>(
 	u: u32,
@@ -43,6 +47,19 @@ fn setup_proposal<T: Config<I>, I: 'static>(
 	(caller, value, beneficiary_lookup)
 }
 
+// Create the pre-requisite information needed to create a treasury `spend` call.
+fn setup_spend_call<T: Config<I>, I: 'static>(
+	u: u32,
+) -> (T::AssetKind, T::AccountId, PayBalanceOf<T, I>, AccountIdLookupOf<T>) {
+	let caller = account("caller", u, SEED);
+
+	let value: PayBalanceOf<T, I> = SEED.into();
+	let beneficiary = account("beneficiary", u, SEED);
+	let beneficiary_lookup = T::Lookup::unlookup(beneficiary);
+	let asset_kind = default_asset_kind::<T, I>();
+	(asset_kind, caller, value, beneficiary_lookup)
+}
+
 // Create proposals that are approved for use in `on_initialize`.
 fn create_approved_proposals<T: Config<I>, I: 'static>(n: u32) -> Result<(), &'static str> {
 	for i in 0..n {
@@ -55,6 +72,16 @@ fn create_approved_proposals<T: Config<I>, I: 'static>(n: u32) -> Result<(), &'s
 	Ok(())
 }
 
+// Create pending payments that are approved for use in `on_initialize`.
+fn create_pending_payments<T: Config<I>, I: 'static>(n: u32) -> Result<(), &'static str> {
+	for i in 0..n {
+		let (asset_kind, _, value, lookup) = setup_spend_call::<T, I>(i);
+		Treasury::<T, I>::spend(RawOrigin::Root.into(), asset_kind, value, lookup)?;
+	}
+	ensure!(<PendingPayments<T, I>>::count() == n, "Enpty pending payments storage");
+	Ok(())
+}
+
 fn setup_pot_account<T: Config<I>, I: 'static>() {
 	let pot_account = Treasury::<T, I>::account_id();
 	let value = T::Currency::minimum_balance().saturating_mul(1_000_000_000u32.into());
@@ -68,11 +95,11 @@ fn assert_last_event<T: Config<I>, I: 'static>(generic_event: <T as Config<I>>::
 benchmarks_instance_pallet! {
 	// This benchmark is short-circuited if `SpendOrigin` cannot provide
 	// a successful origin, in which case `spend` is un-callable and can use weight=0.
-	spend {
+	spend_local {
 		let (_, value, beneficiary_lookup) = setup_proposal::<T, _>(SEED);
 		let origin = T::SpendOrigin::try_successful_origin();
 		let beneficiary = T::Lookup::lookup(beneficiary_lookup.clone()).unwrap();
-		let call = Call::<T, I>::spend { amount: value, beneficiary: beneficiary_lookup };
+		let call = Call::<T, I>::spend_local { amount: value, beneficiary: beneficiary_lookup };
 	}: {
 		if let Ok(origin) = origin.clone() {
 			call.dispatch_bypass_filter(origin)?;
@@ -84,6 +111,24 @@ benchmarks_instance_pallet! {
 		}
 	}
 
+	// This benchmark is short-circuited if `SpendOrigin` cannot provide
+	// a successful origin, in which case `spend` is un-callable and can use weight=0.
+	spend {
+		let (asset_kind, _, value, beneficiary_lookup) = setup_spend_call::<T, I>(SEED);
+		let origin = T::SpendOrigin::try_successful_origin();
+		let beneficiary: T::AccountId = T::Lookup::lookup(beneficiary_lookup.clone()).unwrap();
+		let call = Call::<T, I>::spend { asset_kind, amount: value, beneficiary: beneficiary_lookup };
+	}: {
+		if let Ok(origin) = origin.clone() {
+			call.dispatch_bypass_filter(origin)?;
+		}
+	}
+	verify {
+		if origin.is_ok() {
+			assert_last_event::<T, I>(Event::PaymentQueued{ pending_payment_index: 0, asset_kind, amount: value, beneficiary }.into())
+		}
+	}
+
 	propose_spend {
 		let (caller, value, beneficiary_lookup) = setup_proposal::<T, _>(SEED);
 		// Whitelist caller account from further DB operations.
@@ -138,5 +183,12 @@ benchmarks_instance_pallet! {
 		Treasury::<T, _>::on_initialize(T::BlockNumber::zero());
 	}
 
+	on_initialize_pending_payments {
+		let p in 0 .. T::MaxApprovals::get();
+		create_pending_payments::<T,_>(p)?;
+	}: {
+		Treasury::<T, _>::on_initialize(T::BlockNumber::zero());
+	}
+
 	impl_benchmark_test_suite!(Treasury, crate::tests::new_test_ext(), crate::tests::Test);
 }