[pallet-balances] burn_allow_death extrinsic

substrate/frame/balances/src/benchmarking.rs

@@ -297,6 +297,25 @@ mod benchmarks {
 		assert_eq!(Balances::<T, I>::total_issuance(), ti + delta);
 	}
 
+	// Benchmark `burn_allow_death` extrinsic with the worst possible condition - burn kills the account.
+	#[benchmark]
+	fn burn_allow_death() {
+		let existential_deposit = T::ExistentialDeposit::get();
+		let caller = whitelisted_caller();
+
+		// Give some multiple of the existential deposit
+		let balance = existential_deposit.saturating_mul(ED_MULTIPLIER.into());
+		let _ = <Balances<T, I> as Currency<_>>::make_free_balance_be(&caller, balance);
+
+		// Burn enough to kill the account.
+		let burn_amount = balance - existential_deposit + 1u32.into();
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()), burn_amount);
+
+		assert_eq!(Balances::<T, I>::free_balance(&caller), Zero::zero());
+	}
+
 	impl_benchmark_test_suite! {
 		Balances,
 		crate::tests::ExtBuilder::default().build(),

substrate/frame/balances/src/lib.rs

@@ -767,6 +767,21 @@ pub mod pallet {
 
 			Ok(())
 		}
+
+		/// Burn the specified liquid free balance from the origin account.
+		///
+		/// If the origin's account ends up below the existential deposit as a result
+		/// of the burn, the account will be reaped.
+		#[pallet::call_index(10)]
+		#[pallet::weight(T::WeightInfo::burn_allow_death())]
+		pub fn burn_allow_death(
+			origin: OriginFor<T>,
+			#[pallet::compact] value: T::Balance,
+		) -> DispatchResult {
+			let source = ensure_signed(origin)?;
+			<Self as fungible::Mutate<_>>::burn_from(&source, value, Precision::Exact, Polite)?;
+			Ok(())
+		}
 	}
 
 	impl<T: Config<I>, I: 'static> Pallet<T, I> {

substrate/frame/balances/src/tests/dispatchable_tests.rs

@@ -335,3 +335,39 @@ fn force_adjust_total_issuance_rejects_more_than_inactive() {
 		assert_eq!(Balances::active_issuance(), 10);
 	});
 }
+
+#[test]
+fn burn_allow_death_works() {
+	ExtBuilder::default().build().execute_with(|| {
+		// Prepare account with initial balance
+		let (account, init_balance) = (1, 37);
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), account, init_balance));
+		let init_issuance = Balances::total_issuance();
+
+		// Cannot burn more than what's available
+		assert_noop!(
+			Balances::burn_allow_death(Some(account).into(), init_balance + 1),
+			TokenError::FundsUnavailable,
+		);
+
+		// Burn some funds, without reaping the account
+		let burn_amount_1 = 1;
+		assert_ok!(Balances::burn_allow_death(Some(account).into(), burn_amount_1));
+		System::assert_last_event(RuntimeEvent::Balances(Event::Burned {
+			who: account.clone(),
+			amount: burn_amount_1,
+		}));
+		assert_eq!(Balances::total_issuance(), init_issuance - burn_amount_1);
+		assert_eq!(Balances::total_balance(&account), init_balance - burn_amount_1);
+
+		// Burn some more funds, this time reaping the account
+		let burn_amount_2 = init_balance - burn_amount_1 - <Test as Config>::ExistentialDeposit::get() + 1;
+		assert_ok!(Balances::burn_allow_death(Some(account).into(), burn_amount_2));
+		System::assert_last_event(RuntimeEvent::Balances(Event::Burned {
+			who: account.clone(),
+			amount: burn_amount_2,
+		}));
+		assert_eq!(Balances::total_issuance(), init_issuance - burn_amount_1 - burn_amount_2);
+		assert!(Balances::total_balance(&account).is_zero());
+	});
+}