permissionless bond_extra in nomination pools

frame/nomination-pools/benchmarking/src/lib.rs

@@ -32,7 +32,8 @@ use frame_system::RawOrigin as RuntimeOrigin;
 use pallet_nomination_pools::{
 	BalanceOf, BondExtra, BondedPoolInner, BondedPools, ConfigOp, MaxPoolMembers,
 	MaxPoolMembersPerPool, MaxPools, Metadata, MinCreateBond, MinJoinBond, Pallet as Pools,
-	PoolMembers, PoolRoles, PoolState, RewardPools, SubPoolsStorage,
+	PoolMembers, PoolRoles, PoolState, RewardClaim, RewardClaimPermission, RewardPools,
+	SubPoolsStorage,
 };
 use sp_runtime::traits::{Bounded, StaticLookup, Zero};
 use sp_staking::{EraIndex, StakingInterface};
@@ -654,6 +655,28 @@ frame_benchmarking::benchmarks! {
 		assert!(T::Staking::nominations(Pools::<T>::create_bonded_account(1)).is_none());
 	}
 
+	set_reward_claim {
+		// Create a pool
+		let min_create_bond = Pools::<T>::depositor_min_bond();
+		let (depositor, pool_account) = create_pool_account::<T>(0, min_create_bond);
+
+		// Join pool
+		let min_join_bond = MinJoinBond::<T>::get().max(CurrencyOf::<T>::minimum_balance());
+		let joiner = create_funded_user_with_balance::<T>("joiner", 0, min_join_bond * 4u32.into());
+		let joiner_lookup = T::Lookup::unlookup(joiner.clone());
+		Pools::<T>::join(RuntimeOrigin::Signed(joiner.clone()).into(), min_join_bond, 1)
+			.unwrap();
+
+		// Sanity check join worked
+		assert_eq!(
+			T::Staking::active_stake(&pool_account).unwrap(),
+			min_create_bond + min_join_bond
+		);
+	}:_(RuntimeOrigin::Signed(joiner.clone()), RewardClaim::Permissionless)
+	verify {
+		assert_eq!(RewardClaimPermission::<T>::get(joiner), RewardClaim::Permissionless);
+	}
+
 	impl_benchmark_test_suite!(
 		Pallet,
 		crate::mock::new_test_ext(),

frame/nomination-pools/src/lib.rs

@@ -411,6 +411,21 @@ enum AccountType {
 	Reward,
 }
 
+/// Account to bond pending reward of a member.
+#[derive(Encode, Decode, MaxEncodedLen, Clone, Copy, Debug, PartialEq, Eq, TypeInfo)]
+pub enum RewardClaim {
+	/// Only the pool member themself can claim their reward.
+	Permissioned,
+	/// Anyone can claim the reward of this member.
+	Permissionless,
+}
+
+impl Default for RewardClaim {
+	fn default() -> Self {
+		Self::Permissioned
+	}
+}
+
 /// A member in a pool.
 #[derive(Encode, Decode, MaxEncodedLen, TypeInfo, RuntimeDebugNoBound, CloneNoBound)]
 #[cfg_attr(feature = "std", derive(frame_support::PartialEqNoBound, DefaultNoBound))]
@@ -1316,6 +1331,11 @@ pub mod pallet {
 	pub type ReversePoolIdLookup<T: Config> =
 		CountedStorageMap<_, Twox64Concat, T::AccountId, PoolId, OptionQuery>;
 
+	/// Map from a pool member account to their preference regarding reward payout.
+	#[pallet::storage]
+	pub type RewardClaimPermission<T: Config> =
+		StorageMap<_, Twox64Concat, T::AccountId, RewardClaim, ValueQuery>;
+
 	#[pallet::genesis_config]
 	pub struct GenesisConfig<T: Config> {
 		pub min_join_bond: BalanceOf<T>,
@@ -1473,6 +1493,8 @@ pub mod pallet {
 		PoolIdInUse,
 		/// Pool id provided is not correct/usable.
 		InvalidPoolId,
+		/// Restricted to pending rewards
+		CannotBondFreeBalanceOther,
 	}
 
 	#[derive(Encode, Decode, PartialEq, TypeInfo, frame_support::PalletError, RuntimeDebug)]
@@ -1563,6 +1585,7 @@ pub mod pallet {
 		/// accumulated rewards, see [`BondExtra`].
 		///
 		/// Bonding extra funds implies an automatic payout of all pending rewards as well.
+		/// See `bond_extra_other` to bond pending rewards of `other` members.
 		// NOTE: this transaction is implemented with the sole purpose of readability and
 		// correctness, not optimization. We read/write several storage items multiple times instead
 		// of just once, in the spirit reusing code.
@@ -1573,34 +1596,8 @@ pub mod pallet {
 		)]
 		pub fn bond_extra(origin: OriginFor<T>, extra: BondExtra<BalanceOf<T>>) -> DispatchResult {
 			let who = ensure_signed(origin)?;
-			let (mut member, mut bonded_pool, mut reward_pool) = Self::get_member_with_pools(&who)?;
 
-			// payout related stuff: we must claim the payouts, and updated recorded payout data
-			// before updating the bonded pool points, similar to that of `join` transaction.
-			reward_pool.update_records(bonded_pool.id, bonded_pool.points)?;
-			let claimed =
-				Self::do_reward_payout(&who, &mut member, &mut bonded_pool, &mut reward_pool)?;
-
-			let (points_issued, bonded) = match extra {
-				BondExtra::FreeBalance(amount) =>
-					(bonded_pool.try_bond_funds(&who, amount, BondType::Later)?, amount),
-				BondExtra::Rewards =>
-					(bonded_pool.try_bond_funds(&who, claimed, BondType::Later)?, claimed),
-			};
-
-			bonded_pool.ok_to_be_open()?;
-			member.points =
-				member.points.checked_add(&points_issued).ok_or(Error::<T>::OverflowRisk)?;
-
-			Self::deposit_event(Event::<T>::Bonded {
-				member: who.clone(),
-				pool_id: member.pool_id,
-				bonded,
-				joined: false,
-			});
-			Self::put_member_with_pools(&who, member, bonded_pool, reward_pool);
-
-			Ok(())
+			Self::do_bond_extra(who, None, extra)
 		}
 
 		/// A bonded member can use this to claim their payout based on the rewards that the pool
@@ -1718,6 +1715,7 @@ pub mod pallet {
 			// Now that we know everything has worked write the items to storage.
 			SubPoolsStorage::insert(&member.pool_id, sub_pools);
 			Self::put_member_with_pools(&member_account, member, bonded_pool, reward_pool);
+			<RewardClaimPermission<T>>::remove(member_account);
 
 			Ok(())
 		}
@@ -2117,6 +2115,52 @@ pub mod pallet {
 			ensure!(bonded_pool.can_nominate(&who), Error::<T>::NotNominator);
 			T::Staking::chill(&bonded_pool.bonded_account())
 		}
+
+		/// Bond `extra` more funds from `origin` and
+		/// pending rewards of `other` into their respective pools.
+		///
+		/// Origin can bond extra more funds from free balance and pending rewards
+		/// when `other` is `None`.
+		///
+		/// Origin can bond extra pending rewards of `other` given `Some` is a member and
+		/// set reward claim to Permissionless.
+		#[pallet::call_index(14)]
+		#[pallet::weight(
+			T::WeightInfo::bond_extra_transfer()
+			.max(T::WeightInfo::bond_extra_reward())
+		)]
+		pub fn bond_extra_other(
+			origin: OriginFor<T>,
+			other: Option<AccountIdLookupOf<T>>,
+			extra: BondExtra<BalanceOf<T>>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			Self::do_bond_extra(who, other, extra)
+		}
+
+		/// Sets permission to claim reward.
+		///
+		/// Lets a pool member to choose who can claim pending rewards on their behalf. By default,
+		/// this is `Permissioned` which implies only the pool member themselves can claim their
+		/// pending rewards. If a pool member wishes so, they can set this to `Permissionless` to
+		/// allow any account to claim their rewards and bond extra to the pool.
+		///
+		/// # Arguments
+		///
+		/// * `origin` - Member of a pool.
+		/// * `actor` - Account to claim reward. // improve this
+		#[pallet::call_index(15)]
+		#[pallet::weight(T::DbWeight::get().reads_writes(1, 1))]
+		pub fn set_reward_claim(origin: OriginFor<T>, actor: RewardClaim) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			ensure!(PoolMembers::<T>::contains_key(&who), Error::<T>::PoolMemberNotFound);
+			<RewardClaimPermission<T>>::mutate(who, |source| {
+				*source = actor;
+			});
+			Ok(())
+		}
 	}
 
 	#[pallet::hooks]
@@ -2419,6 +2463,52 @@ impl<T: Config> Pallet<T> {
 		Ok(())
 	}
 
+	fn do_bond_extra(
+		who: T::AccountId,
+		other: Option<AccountIdLookupOf<T>>,
+		extra: BondExtra<BalanceOf<T>>,
+	) -> DispatchResult {
+		let other = other.map(T::Lookup::lookup).transpose()?;
+		let is_bonding_for = other.is_some();
+		let who = other.unwrap_or(who);
+		if is_bonding_for {
+			ensure!(
+				RewardClaimPermission::<T>::get(&who) == RewardClaim::Permissionless,
+				Error::<T>::DoesNotHavePermission
+			);
+			ensure!(extra == BondExtra::Rewards, Error::<T>::CannotBondFreeBalanceOther);
+		}
+
+		let (mut member, mut bonded_pool, mut reward_pool) = Self::get_member_with_pools(&who)?;
+
+		// payout related stuff: we must claim the payouts, and updated recorded payout data
+		// before updating the bonded pool points, similar to that of `join` transaction.
+		reward_pool.update_records(bonded_pool.id, bonded_pool.points)?;
+		let claimed =
+			Self::do_reward_payout(&who, &mut member, &mut bonded_pool, &mut reward_pool)?;
+
+		let (points_issued, bonded) = match extra {
+			BondExtra::FreeBalance(amount) =>
+				(bonded_pool.try_bond_funds(&who, amount, BondType::Later)?, amount),
+			BondExtra::Rewards =>
+				(bonded_pool.try_bond_funds(&who, claimed, BondType::Later)?, claimed),
+		};
+
+		bonded_pool.ok_to_be_open()?;
+		member.points =
+			member.points.checked_add(&points_issued).ok_or(Error::<T>::OverflowRisk)?;
+
+		Self::deposit_event(Event::<T>::Bonded {
+			member: who.clone(),
+			pool_id: member.pool_id,
+			bonded,
+			joined: false,
+		});
+		Self::put_member_with_pools(&who, member, bonded_pool, reward_pool);
+
+		Ok(())
+	}
+
 	/// Ensure the correctness of the state of this pallet.
 	///
 	/// This should be valid before or after each state transition of this pallet.

frame/nomination-pools/src/tests.rs

@@ -2090,10 +2090,18 @@ mod unbond {
 					Error::<T>::MinimumBondNotMet
 				);
 
+				// Make permissionless
+				assert_eq!(RewardClaimPermission::<Runtime>::get(10), RewardClaim::Permissioned);
+				assert_ok!(Pools::set_reward_claim(
+					RuntimeOrigin::signed(20),
+					RewardClaim::Permissionless
+				));
+
 				// but can go to 0
 				assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, 15));
 				assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().active_points(), 0);
 				assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().unbonding_points(), 20);
+				assert_eq!(RewardClaimPermission::<Runtime>::get(20), RewardClaim::Permissioned);
 			})
 	}
 
@@ -4240,6 +4248,39 @@ mod create {
 	}
 }
 
+#[test]
+fn set_claimable_actor_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		// Given
+		Balances::make_free_balance_be(&11, ExistentialDeposit::get() + 2);
+		assert!(!PoolMembers::<Runtime>::contains_key(&11));
+
+		// When
+		assert_ok!(Pools::join(RuntimeOrigin::signed(11), 2, 1));
+
+		// Then
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				Event::Created { depositor: 10, pool_id: 1 },
+				Event::Bonded { member: 10, pool_id: 1, bonded: 10, joined: true },
+				Event::Bonded { member: 11, pool_id: 1, bonded: 2, joined: true },
+			]
+		);
+
+		// Make permissionless
+		assert_eq!(RewardClaimPermission::<Runtime>::get(11), RewardClaim::Permissioned);
+		assert_noop!(
+			Pools::set_reward_claim(RuntimeOrigin::signed(12), RewardClaim::Permissionless),
+			Error::<T>::PoolMemberNotFound
+		);
+		assert_ok!(Pools::set_reward_claim(RuntimeOrigin::signed(11), RewardClaim::Permissionless));
+
+		// then
+		assert_eq!(RewardClaimPermission::<Runtime>::get(11), RewardClaim::Permissionless);
+	});
+}
+
 mod nominate {
 	use super::*;
 
@@ -4552,6 +4593,7 @@ mod bond_extra {
 
 			// when
 			assert_ok!(Pools::bond_extra(RuntimeOrigin::signed(10), BondExtra::Rewards));
+			assert_eq!(Balances::free_balance(&default_reward_account()), 7);
 
 			// then
 			assert_eq!(Balances::free_balance(10), 35);
@@ -4583,6 +4625,71 @@ mod bond_extra {
 			);
 		})
 	}
+
+	#[test]
+	fn bond_extra_other() {
+		ExtBuilder::default().add_members(vec![(20, 20)]).build_and_execute(|| {
+			Balances::make_free_balance_be(&default_reward_account(), 8);
+			// ... if which only 3 is claimable to make sure the reward account does not die.
+			let claimable_reward = 8 - ExistentialDeposit::get();
+			// NOTE: easier to read of we use 3, so let's use the number instead of variable.
+			assert_eq!(claimable_reward, 3, "test is correct if rewards are divisible by 3");
+
+			// given
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().points, 10);
+			assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().points, 20);
+			assert_eq!(BondedPools::<Runtime>::get(1).unwrap().points, 30);
+			assert_eq!(Balances::free_balance(10), 35);
+			assert_eq!(Balances::free_balance(20), 20);
+
+			// Permissioned by default
+			assert_noop!(
+				Pools::bond_extra_other(RuntimeOrigin::signed(80), Some(20), BondExtra::Rewards),
+				Error::<Runtime>::DoesNotHavePermission
+			);
+
+			assert_ok!(Pools::set_reward_claim(
+				RuntimeOrigin::signed(10),
+				RewardClaim::Permissionless
+			));
+			assert_ok!(Pools::bond_extra_other(
+				RuntimeOrigin::signed(50),
+				Some(10),
+				BondExtra::Rewards
+			));
+			assert_eq!(Balances::free_balance(&default_reward_account()), 7);
+
+			// then
+			assert_eq!(Balances::free_balance(10), 35);
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().points, 10 + 1);
+			assert_eq!(BondedPools::<Runtime>::get(1).unwrap().points, 30 + 1);
+
+			// when
+			assert_noop!(
+				Pools::bond_extra_other(RuntimeOrigin::signed(40), None, BondExtra::Rewards),
+				Error::<Runtime>::PoolMemberNotFound
+			);
+			assert_ok!(Pools::set_reward_claim(
+				RuntimeOrigin::signed(20),
+				RewardClaim::Permissionless
+			));
+			assert_noop!(
+				Pools::bond_extra_other(
+					RuntimeOrigin::signed(20),
+					Some(20),
+					BondExtra::FreeBalance(10)
+				),
+				Error::<Runtime>::CannotBondFreeBalanceOther
+			);
+
+			// then
+			assert_eq!(Balances::free_balance(20), 20);
+			// 20's share of the rewards is the other 2/3 of the rewards, since they have 20/30 of
+			// the shares
+			assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().points, 20);
+			assert_eq!(BondedPools::<Runtime>::get(1).unwrap().points, 31);
+		})
+	}
 }
 
 mod update_roles {