Use Free Balance for Check

frame/balances/src/lib.rs

@@ -996,12 +996,13 @@ pub mod pallet {
 			frozen_balance
 		}
 
+		// TODO: rename to non_lockable_balance
 		impl_rpc! {
 			fn usable_balance_rpc(who: impl Borrow<T::AccountId>) -> RuntimeDispatchInfo<T::Balance> {
+				let account = Self::account(who.borrow());
+
 				RuntimeDispatchInfo {
-					// TODO: balances
-					usable_balance: Zero::zero(),
-					// usable_balance: Self::usable_balance(who.borrow()),
+					usable_balance: account.usable(Reasons::Misc, Self::frozen_balance(who)),
 				}
 			}
 		}
@@ -1937,22 +1938,6 @@ pub mod pallet {
 
 			Self::update_locks(who, &locks);
 		}
-
-		// /// Get the balance of an account that can be used for transfers, reservations, or any other
-		// /// non-locking, non-transaction-fee activity. Will be at most `free_balance`.
-		// fn usable_balance(who: &T::AccountId) -> Self::Balance {
-		// 	let account = Self::account(who);
-
-		// 	account.usable(Reasons::Misc, Self::frozen_balance(who))
-		// }
-
-		// /// Get the balance of an account that can be used for paying transaction fees (not tipping,
-		// /// or any other kind of fees, though). Will be at most `free_balance`.
-		// fn usable_balance_for_fees(who: &T::AccountId) -> Self::Balance {
-		// 	let account = Self::account(who);
-
-		// 	account.usable(Reasons::Fee, Self::frozen_balance(who))
-		// }
 	}
 
 	impl<T: Config<I>, I: 'static> NamedReservableCurrency<T::AccountId> for Pallet<T, I>

frame/bridge/relay-authorities/src/lib.rs

@@ -303,11 +303,10 @@ decl_module! {
 				find_authority_position::<T, I>(&<Authorities<T, I>>::get(), &account_id).is_none(),
 				<Error<T, I>>::AuthorityAE
 			);
-			// TODO: balances
-			// ensure!(
-			// 	<RingCurrency<T, I>>::usable_balance(&account_id) > stake,
-			// 	<Error<T, I>>::StakeIns
-			// );
+			ensure!(
+				<RingCurrency<T, I>>::free_balance(&account_id) > stake,
+				<Error<T, I>>::StakeIns
+			);
 
 			<Candidates<T, I>>::try_mutate(|candidates| {
 				ensure!(

frame/bridge/relayer-game/src/lib.rs

@@ -249,11 +249,10 @@ impl<T: Config<I>, I: Instance> Module<T, I> {
 	) -> Result<RingBalance<T, I>, DispatchError> {
 		let stake = T::RelayerGameAdjustor::estimate_stake(round, affirmations_count);
 
-		// TODO: balances
-		// ensure!(
-		// 	T::RingCurrency::usable_balance(relayer) >= stake,
-		// 	<Error<T, I>>::StakeIns
-		// );
+		ensure!(
+			T::RingCurrency::free_balance(relayer) >= stake,
+			<Error<T, I>>::StakeIns
+		);
 
 		Ok(stake)
 	}

frame/claims/src/lib.rs

@@ -350,10 +350,9 @@ impl<T: Config> Module<T> {
 	}
 
 	fn pot<C: LockableCurrency<T::AccountId>>() -> C::Balance {
-		// TODO: balances
-		sp_runtime::traits::Zero::zero()
 		// Already lock minimal balance in the account, no need to worry about to be 0.
-		// C::usable_balance(&Self::account_id())
+		// There is not other lock on module account, so `free_balance == usable_balance`.
+		C::free_balance(&Self::account_id())
 	}
 
 	// Constructs the message that RPC's `personal_sign` and `sign` would sign.

frame/staking/src/impls.rs

@@ -268,11 +268,11 @@ impl<T: Config> Pallet<T> {
 
 		let module_account = Self::account_id();
 
-		// TODO: balances
-		// ensure!(
-		// 	T::RingCurrency::usable_balance(&module_account) >= validator_total_payout,
-		// 	<Error<T>>::PayoutIns
-		// );
+		// There is not lock on module account, so `free_balance == usable_balance`.
+		ensure!(
+			T::RingCurrency::free_balance(&module_account) >= validator_total_payout,
+			<Error<T>>::PayoutIns
+		);
 
 		let validator_prefs = Self::eras_validator_prefs(&era, &validator_stash);
 		// Validator first gets a cut off the top.
@@ -351,6 +351,7 @@ impl<T: Config> Pallet<T> {
 	/// 	DO NOT modify the locks' staking amount outside this function.
 	pub fn update_ledger(controller: &AccountId<T>, ledger: &StakingLedgerT<T>) {
 		let StakingLedger {
+			stash,
 			active,
 			active_kton,
 			ring_staking_lock,
@@ -360,13 +361,13 @@ impl<T: Config> Pallet<T> {
 
 		T::RingCurrency::set_lock(
 			STAKING_ID,
-			&ledger.stash,
+			&stash,
 			active.saturating_add(ring_staking_lock.locked_amount()),
 			WithdrawReasons::all(),
 		);
 		T::KtonCurrency::set_lock(
 			STAKING_ID,
-			&ledger.stash,
+			&stash,
 			active_kton.saturating_add(kton_staking_lock.locked_amount()),
 			WithdrawReasons::all(),
 		);

frame/staking/src/lib.rs

@@ -1574,9 +1574,14 @@ pub mod pallet {
 
 					// check total free balance and locked one
 					// strict on punishing in kton
-					// TODO: balances
-					if true {
-					// if T::KtonCurrency::usable_balance(stash) >= kton_slash {
+					if T::KtonCurrency::ensure_can_withdraw(
+						stash,
+						kton_slash,
+						Reasons::all(),
+						T::KtonCurrency::free_balance(stash).saturating_sub(kton_slash),
+					)
+					.is_ok()
+					{
 						*active_deposit_ring = active_deposit_ring.saturating_sub(item.value);
 
 						let imbalance = T::KtonCurrency::slash(stash, kton_slash).0;

frame/support/src/structs.rs

@@ -107,9 +107,11 @@ where
 {
 	#[inline]
 	pub fn locked_amount(&self) -> Balance {
-		self.unbondings.iter().fold(Zero::zero(), |acc, unbonding| {
-			acc.saturating_add(unbonding.amount)
-		})
+		self.unbondings
+			.iter()
+			.fold(self.staking_amount, |acc, unbonding| {
+				acc.saturating_add(unbonding.amount)
+			})
 	}
 
 	#[inline]

frame/wormhole/backing/ethereum/src/lib.rs

@@ -430,10 +430,8 @@ pub mod pallet {
 
 			let fee_account = Self::fee_account_id();
 			let sync_reward = T::SyncReward::get().min(
-				// TODO: balances
-				Zero::zero()
-				// T::RingCurrency::usable_balance(&fee_account)
-					// .saturating_sub(T::RingCurrency::minimum_balance()),
+				T::RingCurrency::free_balance(&fee_account)
+					.saturating_sub(T::RingCurrency::minimum_balance()),
 			);
 
 			if !sync_reward.is_zero() {
@@ -554,11 +552,10 @@ pub mod pallet {
 		/// Return the amount of money in the pot.
 		// The existential deposit is not part of the pot so backing account never gets deleted.
 		pub fn pot<C: LockableCurrency<T::AccountId>>() -> C::Balance {
-			// TODO: balances
-			Zero::zero()
-			// C::usable_balance(&Self::account_id())
-			// 	// Must never be less than 0 but better be safe.
-			// 	.saturating_sub(C::minimum_balance())
+			// There is not lock on module account, so `free_balance == usable_balance`.
+			C::usable_balance(&Self::account_id())
+				// Must never be less than 0 but better be safe.
+				.saturating_sub(C::minimum_balance())
 		}
 
 		fn redeem_token(