Full Unbond in Staking

polkadot/runtime/westend/src/weights/pallet_staking.rs

@@ -826,4 +826,8 @@ impl<T: frame_system::Config> pallet_staking::WeightInfo for WeightInfo<T> {
 			.saturating_add(T::DbWeight::get().reads(5))
 			.saturating_add(T::DbWeight::get().writes(4))
 	}
+
+	fn full_unbond() -> Weight {
+		todo!()
+	}
 }

prdoc/pr_3811.prdoc

@@ -0,0 +1,10 @@
+title: "[pallet_staking] Staking `full_unbond`"
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      Full unbond when staking such that to fully unbond as a validator or nominator, chilled occurs first
+      before unbonding
+
+crates:
+  - name: pallet-staking

substrate/frame/nomination-pools/test-staking/src/lib.rs

@@ -151,14 +151,6 @@ fn pool_lifecycle_e2e() {
 			]
 		);
 
-		// as soon as all members have left, the depositor can try to unbond, but since the
-		// min-nominator intention is set, they must chill first.
-		assert_noop!(
-			Pools::unbond(RuntimeOrigin::signed(10), 10, 50),
-			pallet_staking::Error::<Runtime>::InsufficientBond
-		);
-
-		assert_ok!(Pools::chill(RuntimeOrigin::signed(10), 1));
 		assert_ok!(Pools::unbond(RuntimeOrigin::signed(10), 10, 50));
 
 		assert_eq!(

substrate/frame/staking/src/benchmarking.rs

@@ -962,6 +962,32 @@ benchmarks! {
 		assert_eq!(Staking::<T>::inspect_bond_state(&stash), Ok(LedgerIntegrityState::Ok));
 	}
 
+	full_unbond {
+		// clean up any existing state.
+		clear_validators_and_nominators::<T>();
+
+		// setup the worst case list scenario.
+		let total_issuance = T::Currency::total_issuance();
+		// the weight the nominator will start at. The value used here is expected to be
+		// significantly higher than the first position in a list (e.g. the first bag threshold).
+		let origin_weight = BalanceOf::<T>::try_from(952_994_955_240_703u128)
+			.map_err(|_| "balance expected to be a u128")
+			.unwrap();
+		let scenario = ListScenario::<T>::new(origin_weight, false)?;
+
+		let stash = scenario.origin_stash1.clone();
+		let controller = scenario.origin_controller1.clone();
+		let ledger = Ledger::<T>::get(&controller).ok_or("ledger not created before")?;
+		let original_bonded: BalanceOf<T> = ledger.active;
+
+		whitelist_account!(controller);
+	}: _(RawOrigin::Signed(controller.clone()))
+	verify {
+		let ledger = Ledger::<T>::get(&controller).ok_or("ledger not created after")?;
+		let new_bonded: BalanceOf<T> = ledger.active;
+		assert!(original_bonded > new_bonded);
+	}
+
 	impl_benchmark_test_suite!(
 		Staking,
 		crate::mock::ExtBuilder::default().has_stakers(true),

substrate/frame/staking/src/pallet/impls.rs

@@ -51,7 +51,8 @@ use crate::{
 	election_size_tracker::StaticTracker, log, slashing, weights::WeightInfo, ActiveEraInfo,
 	BalanceOf, EraInfo, EraPayout, Exposure, ExposureOf, Forcing, IndividualExposure,
 	LedgerIntegrityState, MaxNominationsOf, MaxWinnersOf, Nominations, NominationsQuota,
-	PositiveImbalanceOf, RewardDestination, SessionInterface, StakingLedger, ValidatorPrefs,
+	PositiveImbalanceOf, RewardDestination, SessionInterface, StakingLedger, UnlockChunk,
+	ValidatorPrefs,
 };
 
 use super::pallet::*;
@@ -1132,6 +1133,86 @@ impl<T: Config> Pallet<T> {
 	) -> Exposure<T::AccountId, BalanceOf<T>> {
 		EraInfo::<T>::get_full_exposure(era, account)
 	}
+
+	/// Unbonds a controller.
+	pub(crate) fn do_unbond(
+		controller: T::AccountId,
+		value: BalanceOf<T>,
+	) -> Result<Option<Weight>, DispatchError> {
+		let unlocking = Self::ledger(Controller(controller.clone())).map(|l| l.unlocking.len())?;
+
+		// if there are no unlocking chunks available, try to withdraw chunks older than
+		// `BondingDuration` to proceed with the unbonding.
+		let maybe_withdraw_weight = {
+			if unlocking == T::MaxUnlockingChunks::get() as usize {
+				let real_num_slashing_spans =
+					Self::slashing_spans(&controller).map_or(0, |s| s.iter().count());
+				Some(Self::do_withdraw_unbonded(&controller, real_num_slashing_spans as u32)?)
+			} else {
+				None
+			}
+		};
+
+		// we need to fetch the ledger again because it may have been mutated in the call
+		// to `Self::do_withdraw_unbonded` above.
+		let mut ledger = Self::ledger(Controller(controller.clone()))?;
+		let mut value = value.min(ledger.active);
+		let stash = ledger.stash.clone();
+
+		ensure!(
+			ledger.unlocking.len() < T::MaxUnlockingChunks::get() as usize,
+			Error::<T>::NoMoreChunks,
+		);
+
+		if !value.is_zero() {
+			ledger.active -= value;
+
+			// Avoid there being a dust balance left in the staking system.
+			if ledger.active < T::Currency::minimum_balance() {
+				value += ledger.active;
+				ledger.active = Zero::zero();
+			}
+
+			let min_active_bond = if Nominators::<T>::contains_key(&stash) {
+				MinNominatorBond::<T>::get()
+			} else if Validators::<T>::contains_key(&stash) {
+				MinValidatorBond::<T>::get()
+			} else {
+				Zero::zero()
+			};
+
+			// Make sure that the user maintains enough active bond for their role.
+			// If a user runs into this error, they should chill first.
+			ensure!(ledger.active >= min_active_bond, Error::<T>::InsufficientBond);
+
+			// Note: in case there is no current era it is fine to bond one era more.
+			let era = Self::current_era()
+				.unwrap_or(0)
+				.defensive_saturating_add(T::BondingDuration::get());
+			if let Some(chunk) = ledger.unlocking.last_mut().filter(|chunk| chunk.era == era) {
+				// To keep the chunk count down, we only keep one chunk per era. Since
+				// `unlocking` is a FiFo queue, if a chunk exists for `era` we know that it will
+				// be the last one.
+				chunk.value = chunk.value.defensive_saturating_add(value)
+			} else {
+				ledger
+					.unlocking
+					.try_push(UnlockChunk { value, era })
+					.map_err(|_| Error::<T>::NoMoreChunks)?;
+			};
+			// NOTE: ledger must be updated prior to calling `Self::weight_of`.
+			ledger.update()?;
+
+			// update this staker in the sorted list, if they exist in it.
+			if T::VoterList::contains(&stash) {
+				let _ = T::VoterList::on_update(&stash, Self::weight_of(&stash)).defensive();
+			}
+
+			Self::deposit_event(Event::<T>::Unbonded { stash, amount: value });
+		}
+
+		Ok(maybe_withdraw_weight)
+	}
 }
 
 impl<T: Config> Pallet<T> {

substrate/frame/staking/src/pallet/mod.rs

@@ -24,8 +24,8 @@ use frame_election_provider_support::{
 use frame_support::{
 	pallet_prelude::*,
 	traits::{
-		Currency, Defensive, DefensiveSaturating, EnsureOrigin, EstimateNextNewSession, Get,
-		InspectLockableCurrency, LockableCurrency, OnUnbalanced, UnixTime, WithdrawReasons,
+		Currency, Defensive, EnsureOrigin, EstimateNextNewSession, Get, InspectLockableCurrency,
+		LockableCurrency, OnUnbalanced, UnixTime, WithdrawReasons,
 	},
 	weights::Weight,
 	BoundedVec,
@@ -1038,79 +1038,15 @@ pub mod pallet {
 			#[pallet::compact] value: BalanceOf<T>,
 		) -> DispatchResultWithPostInfo {
 			let controller = ensure_signed(origin)?;
-			let unlocking =
-				Self::ledger(Controller(controller.clone())).map(|l| l.unlocking.len())?;
-
-			// if there are no unlocking chunks available, try to withdraw chunks older than
-			// `BondingDuration` to proceed with the unbonding.
-			let maybe_withdraw_weight = {
-				if unlocking == T::MaxUnlockingChunks::get() as usize {
-					let real_num_slashing_spans =
-						Self::slashing_spans(&controller).map_or(0, |s| s.iter().count());
-					Some(Self::do_withdraw_unbonded(&controller, real_num_slashing_spans as u32)?)
-				} else {
-					None
-				}
-			};
-
-			// we need to fetch the ledger again because it may have been mutated in the call
-			// to `Self::do_withdraw_unbonded` above.
-			let mut ledger = Self::ledger(Controller(controller))?;
-			let mut value = value.min(ledger.active);
-			let stash = ledger.stash.clone();
-
-			ensure!(
-				ledger.unlocking.len() < T::MaxUnlockingChunks::get() as usize,
-				Error::<T>::NoMoreChunks,
-			);
-
-			if !value.is_zero() {
-				ledger.active -= value;
 
-				// Avoid there being a dust balance left in the staking system.
-				if ledger.active < T::Currency::minimum_balance() {
-					value += ledger.active;
-					ledger.active = Zero::zero();
-				}
-
-				let min_active_bond = if Nominators::<T>::contains_key(&stash) {
-					MinNominatorBond::<T>::get()
-				} else if Validators::<T>::contains_key(&stash) {
-					MinValidatorBond::<T>::get()
-				} else {
-					Zero::zero()
-				};
-
-				// Make sure that the user maintains enough active bond for their role.
-				// If a user runs into this error, they should chill first.
-				ensure!(ledger.active >= min_active_bond, Error::<T>::InsufficientBond);
-
-				// Note: in case there is no current era it is fine to bond one era more.
-				let era = Self::current_era()
-					.unwrap_or(0)
-					.defensive_saturating_add(T::BondingDuration::get());
-				if let Some(chunk) = ledger.unlocking.last_mut().filter(|chunk| chunk.era == era) {
-					// To keep the chunk count down, we only keep one chunk per era. Since
-					// `unlocking` is a FiFo queue, if a chunk exists for `era` we know that it will
-					// be the last one.
-					chunk.value = chunk.value.defensive_saturating_add(value)
-				} else {
-					ledger
-						.unlocking
-						.try_push(UnlockChunk { value, era })
-						.map_err(|_| Error::<T>::NoMoreChunks)?;
-				};
-				// NOTE: ledger must be updated prior to calling `Self::weight_of`.
-				ledger.update()?;
-
-				// update this staker in the sorted list, if they exist in it.
-				if T::VoterList::contains(&stash) {
-					let _ = T::VoterList::on_update(&stash, Self::weight_of(&stash)).defensive();
-				}
+			let ledger = Self::ledger(StakingAccount::Controller(controller.clone()))?;
 
-				Self::deposit_event(Event::<T>::Unbonded { stash, amount: value });
+			if value == ledger.total {
+				Self::chill_stash(&ledger.stash);
 			}
 
+			let maybe_withdraw_weight = Self::do_unbond(controller, value)?;
+
 			let actual_weight = if let Some(withdraw_weight) = maybe_withdraw_weight {
 				Some(T::WeightInfo::unbond().saturating_add(withdraw_weight))
 			} else {
@@ -2085,6 +2021,29 @@ pub mod pallet {
 			);
 			Ok(())
 		}
+
+		/// Fully Unbonds by Chilling first
+		/// Emits `Unbonded`.
+		#[pallet::call_index(30)]
+		#[pallet::weight(
+		T::WeightInfo::withdraw_unbonded_kill(SPECULATIVE_NUM_SPANS).saturating_add(T::WeightInfo::full_unbond()))
+		]
+		pub fn full_unbond(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
+			let controller = ensure_signed(origin)?;
+
+			let ledger = Self::ledger(StakingAccount::Controller(controller.clone()))?;
+
+			Self::chill_stash(&ledger.stash);
+
+			let maybe_withdraw_weight = Self::do_unbond(controller, ledger.active)?;
+			let actual_weight = if let Some(withdraw_weight) = maybe_withdraw_weight {
+				Some(T::WeightInfo::full_unbond().saturating_add(withdraw_weight))
+			} else {
+				Some(T::WeightInfo::full_unbond())
+			};
+
+			Ok(actual_weight.into())
+		}
 	}
 }
 

substrate/frame/staking/src/tests.rs

@@ -4069,6 +4069,43 @@ fn test_multi_page_payout_stakers_by_page() {
 	});
 }
 
+#[test]
+fn full_unbond_works() {
+	//
+	// * Should test
+	// * Given an account being bonded [and chosen as a validator](not mandatory)
+	// * it can force unbond a portion of its funds from the stash account.
+	ExtBuilder::default().nominate(false).build_and_execute(|| {
+		// Set payee to stash.
+		assert_ok!(Staking::set_payee(RuntimeOrigin::signed(11), RewardDestination::Stash));
+
+		// Give account 11 some large free balance greater than total
+		let _ = Balances::make_free_balance_be(&11, 1000000);
+
+		// confirm that 10 is a normal validator and gets paid at the end of the era.
+		mock::start_active_era(1);
+
+		// Initial state of 11
+		assert_eq!(
+			Staking::ledger(11.into()).unwrap(),
+			StakingLedgerInspect {
+				stash: 11,
+				total: 1000,
+				active: 1000,
+				unlocking: Default::default(),
+				legacy_claimed_rewards: bounded_vec![],
+			}
+		);
+
+		mock::start_active_era(2);
+		assert_eq!(active_era(), 2);
+
+		// Force Unbond all of the funds in stash which makes the call to chill first.
+		let res = Staking::full_unbond(RuntimeOrigin::signed(11));
+		assert!(res.is_ok());
+	})
+}
+
 #[test]
 fn test_multi_page_payout_stakers_backward_compatible() {
 	// Test that payout_stakers work in general and that it pays the correct amount of reward.