upstream into

frame/nomination-pools/src/lib.rs

@@ -1393,15 +1393,15 @@ pub mod pallet {
 		/// `NoMoreChunks` error from the staking system.
 		#[pallet::weight(T::WeightInfo::unbond())]
 		#[transactional]
-		pub fn unbond_other(
+		pub fn unbond(
 			origin: OriginFor<T>,
 			delegator_account: T::AccountId,
 			mut unbonding_points: BalanceOf<T>,
 		) -> DispatchResult {
 			let caller = ensure_signed(origin)?;
 			let (mut delegator, mut bonded_pool, mut reward_pool) =
 				Self::get_delegator_with_pools(&delegator_account)?;
-			bonded_pool.ok_to_unbond_other_with(&caller, &delegator_account, &delegator)?;
+			bonded_pool.ok_to_unbond_with(&caller, &delegator_account, &delegator)?;
 
 			unbonding_points = unbonding_points.min(delegator.active_points());
 			// Claim the the payout prior to unbonding. Once the user is unbonding their points
@@ -1520,7 +1520,7 @@ pub mod pallet {
 			let mut sub_pools = SubPoolsStorage::<T>::get(delegator.pool_id)
 				.defensive_ok_or_else(|| Error::<T>::SubPoolsNotFound)?;
 
-			let should_remove_pool = bonded_pool.ok_to_withdraw_unbonded_other_with(
+			let should_remove_pool = bonded_pool.ok_to_withdraw_unbonded_with(
 				&caller,
 				&delegator_account,
 				&delegator,
@@ -1580,9 +1580,9 @@ pub mod pallet {
 				// delegator being reaped.
 				Delegators::<T>::remove(&delegator_account);
 				if should_remove_pool {
+					let reward_account = bonded_pool.reward_account();
 					ReversePoolIdLookup::<T>::remove(bonded_pool.bonded_account());
 					RewardPools::<T>::remove(delegator.pool_id);
-					Self::deposit_event(Event::<T>::Destroyed { pool_id: delegator.pool_id });
 					SubPoolsStorage::<T>::remove(delegator.pool_id);
 					// Kill accounts from storage by making their balance go below ED. We assume
 					// that the accounts have no references that would prevent destruction once we
@@ -1592,20 +1592,29 @@ pub mod pallet {
 							.unwrap_or_default(),
 						Zero::zero()
 					);
-					T::Currency::make_free_balance_be(&bonded_pool.reward_account(), Zero::zero());
+					let reward_pool_remaining = T::Currency::free_balance(&reward_account);
+					// This shouldn't fail, but if it does we don't really care
+					let _ = T::Currency::transfer(
+						&reward_account,
+						&delegator_account,
+						reward_pool_remaining,
+						ExistenceRequirement::AllowDeath,
+					);
+					T::Currency::make_free_balance_be(&reward_account, Zero::zero());
 					T::Currency::make_free_balance_be(&bonded_pool.bonded_account(), Zero::zero());
+					Self::deposit_event(Event::<T>::Destroyed { pool_id: delegator.pool_id });
 					bonded_pool.remove();
 					None
 				} else {
 					bonded_pool.dec_delegators().put();
 					SubPoolsStorage::<T>::insert(&delegator.pool_id, sub_pools);
-					Some(T::WeightInfo::withdraw_unbonded_other_update(num_slashing_spans))
+					Some(T::WeightInfo::withdraw_unbonded_update(num_slashing_spans))
 				}
 			} else {
 				// we certainly don't need to delete any pools, because no one is being removed.
 				SubPoolsStorage::<T>::insert(&delegator.pool_id, sub_pools);
 				Delegators::<T>::insert(&delegator_account, delegator);
-				Some(T::WeightInfo::withdraw_unbonded_other_update(num_slashing_spans))
+				Some(T::WeightInfo::withdraw_unbonded_update(num_slashing_spans))
 			};
 
 			Ok(post_info_weight.into())

frame/nomination-pools/src/mock.rs

@@ -283,9 +283,9 @@ pub(crate) fn pool_events_since_last_call() -> Vec<super::Event<Runtime>> {
 ///
 /// This is useful for backwards compatibility with the majority of tests that only deal with full
 /// unbonding, not partial unbonding.
-pub fn fully_unbond_other(origin: Origin, delegator: AccountId) -> DispatchResult {
+pub fn fully_unbond(origin: Origin, delegator: AccountId) -> DispatchResult {
 	let points = Delegators::<Runtime>::get(&delegator).map(|d| d.points).unwrap_or_default();
-	Pools::unbond_other(origin, delegator, points)
+	Pools::unbond(origin, delegator, points)
 }
 
 #[cfg(test)]