// This file is part of Substrate.

// Copyright (C) Parity Technologies (UK) Ltd.

// SPDX-License-Identifier: Apache-2.0

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

// 	http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

//! # Balances Pallet

//!

//! The Balances pallet provides functionality for handling accounts and balances for a single

//! token.

//!

//! It makes heavy use of concepts such as Holds and Freezes from the

//! [`frame_support::traits::fungible`] traits, therefore you should read and understand those docs

//! as a prerequisite to understanding this pallet.

//!

//! Also see the [`frame_tokens`] reference docs for higher level information regarding the

//! place of this palet in FRAME.

//!

//! ## Overview

//!

//! The Balances pallet provides functions for:

//!

//! - Getting and setting free balances.

//! - Retrieving total, reserved and unreserved balances.

//! - Repatriating a reserved balance to a beneficiary account that exists.

//! - Transferring a balance between accounts (when not reserved).

//! - Slashing an account balance.

//! - Account creation and removal.

//! - Managing total issuance.

//! - Setting and managing locks.

//!

//! ### Terminology

//!

//! - **Reaping an account:** The act of removing an account by resetting its nonce. Happens after

//!   its total balance has become less than the Existential Deposit.

//!

//! ### Implementations

//!

//! The Balances pallet provides implementations for the following [`fungible`] traits. If these

//! traits provide the functionality that you need, then you should avoid tight coupling with the

//! Balances pallet.

//!

//! - [`fungible::Inspect`]

//! - [`fungible::Mutate`]

//! - [`fungible::Unbalanced`]

//! - [`fungible::Balanced`]

//! - [`fungible::BalancedHold`]

//! - [`fungible::InspectHold`]

//! - [`fungible::MutateHold`]

//! - [`fungible::InspectFreeze`]

//! - [`fungible::MutateFreeze`]

//! - [`fungible::Imbalance`]

//!

//! It also implements the following [`Currency`] related traits, however they are deprecated and

//! will eventually be removed.

//!

//! - [`Currency`]: Functions for dealing with a fungible assets system.

//! - [`ReservableCurrency`]

//! - [`NamedReservableCurrency`](frame_support::traits::NamedReservableCurrency):

//! Functions for dealing with assets that can be reserved from an account.

//! - [`LockableCurrency`](frame_support::traits::LockableCurrency): Functions for

//! dealing with accounts that allow liquidity restrictions.

//! - [`Imbalance`](frame_support::traits::Imbalance): Functions for handling

//! imbalances between total issuance in the system and account balances. Must be used when a

//! function creates new funds (e.g. a reward) or destroys some funds (e.g. a system fee).

//!

//! ## Usage

//!

//! The following examples show how to use the Balances pallet in your custom pallet.

//!

//! ### Examples from the FRAME

//!

//! The Contract pallet uses the `Currency` trait to handle gas payment, and its types inherit from

//! `Currency`:

//!

//! ```

//! use frame_support::traits::Currency;

//! # pub trait Config: frame_system::Config {

//! #   type Currency: Currency<Self::AccountId>;

//! # }

//!

//! pub type BalanceOf<T> = <<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;

//! pub type NegativeImbalanceOf<T> = <<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::NegativeImbalance;

//!

//! # fn main() {}

//! ```

//!

//! The Staking pallet uses the `LockableCurrency` trait to lock a stash account's funds:

//!

//! ```

//! use frame_support::traits::{WithdrawReasons, LockableCurrency};

//! use sp_runtime::traits::Bounded;

//! pub trait Config: frame_system::Config {

//!     type Currency: LockableCurrency<Self::AccountId, Moment=frame_system::pallet_prelude::BlockNumberFor<Self>>;

//! }

//! # struct StakingLedger<T: Config> {

//! #   stash: <T as frame_system::Config>::AccountId,

//! #   total: <<T as Config>::Currency as frame_support::traits::Currency<<T as frame_system::Config>::AccountId>>::Balance,

//! #   phantom: std::marker::PhantomData<T>,

//! # }

//! # const STAKING_ID: [u8; 8] = *b"staking ";

//!

//! fn update_ledger<T: Config>(

//!     controller: &T::AccountId,

//!     ledger: &StakingLedger<T>

//! ) {

//!     T::Currency::set_lock(

//!         STAKING_ID,

//!         &ledger.stash,

//!         ledger.total,

//!         WithdrawReasons::all()

//!     );

//!     // <Ledger<T>>::insert(controller, ledger); // Commented out as we don't have access to Staking's storage here.

//! }

//! # fn main() {}

//! ```

//!

//! ## Genesis config

//!

//! The Balances pallet depends on the [`GenesisConfig`].

//!

//! ## Assumptions

//!

//! * Total issued balanced of all accounts should be less than `Config::Balance::max_value()`.

//! * Existential Deposit is set to a value greater than zero.

//!

//! Note, you may find the Balances pallet still functions with an ED of zero when the

//! `insecure_zero_ed` cargo feature is enabled. However this is not a configuration which is

//! generally supported, nor will it be.

//!

//! [`frame_tokens`]: ../polkadot_sdk_docs/reference_docs/frame_tokens/index.html

#![cfg_attr(not(feature = "std"), no_std)]

mod benchmarking;

mod impl_currency;

mod impl_fungible;

pub mod migration;

mod tests;

mod types;

pub mod weights;

extern crate alloc;

use alloc::vec::Vec;

use codec::{Codec, MaxEncodedLen};

use core::{cmp, fmt::Debug, mem, result};

use frame_support::{

	ensure,

	pallet_prelude::DispatchResult,

	traits::{

		tokens::{

			fungible, BalanceStatus as Status, DepositConsequence,

			Fortitude::{self, Force, Polite},

			IdAmount,

			Preservation::{Expendable, Preserve, Protect},

			WithdrawConsequence,

		},

		Currency, Defensive, Get, OnUnbalanced, ReservableCurrency, StoredMap,

	},

	BoundedSlice, WeakBoundedVec,

};

use frame_system as system;

pub use impl_currency::{NegativeImbalance, PositiveImbalance};

use scale_info::TypeInfo;

use sp_runtime::{

	traits::{

		AtLeast32BitUnsigned, Bounded, CheckedAdd, CheckedSub, MaybeSerializeDeserialize,

		Saturating, StaticLookup, Zero,

	},

	ArithmeticError, DispatchError, FixedPointOperand, Perbill, RuntimeDebug, TokenError,

};

pub use types::{

	AccountData, AdjustmentDirection, BalanceLock, DustCleaner, ExtraFlags, Reasons, ReserveData,

};

pub use weights::WeightInfo;

pub use pallet::*;

const LOG_TARGET: &str = "runtime::balances";

type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;

pub mod pallet {

	use super::*;

	use frame_support::{

		pallet_prelude::*,

		traits::{fungible::Credit, tokens::Precision, VariantCount, VariantCountOf},

	};

	use frame_system::pallet_prelude::*;

	pub type CreditOf<T, I> = Credit<<T as frame_system::Config>::AccountId, Pallet<T, I>>;

	/// Default implementations of [`DefaultConfig`], which can be used to implement [`Config`].

	pub mod config_preludes {

		use super::*;

		use frame_support::{derive_impl, traits::ConstU64};

		pub struct TestDefaultConfig;

		#[derive_impl(frame_system::config_preludes::TestDefaultConfig, no_aggregated_types)]

		impl frame_system::DefaultConfig for TestDefaultConfig {}

		#[frame_support::register_default_impl(TestDefaultConfig)]

		impl DefaultConfig for TestDefaultConfig {

			#[inject_runtime_type]

			type RuntimeEvent = ();

			#[inject_runtime_type]

			type RuntimeHoldReason = ();

			#[inject_runtime_type]

			type RuntimeFreezeReason = ();

			type Balance = u64;

			type ExistentialDeposit = ConstU64<1>;

			type ReserveIdentifier = ();

			type FreezeIdentifier = Self::RuntimeFreezeReason;

			type DustRemoval = ();

			type MaxLocks = ConstU32<100>;

			type MaxReserves = ConstU32<100>;

			type MaxFreezes = VariantCountOf<Self::RuntimeFreezeReason>;

			type WeightInfo = ();

		}

	}

	#[pallet::config(with_default)]

	pub trait Config<I: 'static = ()>: frame_system::Config {

		/// The overarching event type.

		#[pallet::no_default_bounds]

		type RuntimeEvent: From<Event<Self, I>>

			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;

		/// The overarching hold reason.

		#[pallet::no_default_bounds]

		type RuntimeHoldReason: Parameter + Member + MaxEncodedLen + Copy + VariantCount;

		/// The overarching freeze reason.

		#[pallet::no_default_bounds]

		type RuntimeFreezeReason: VariantCount;

		/// Weight information for extrinsics in this pallet.

		type WeightInfo: WeightInfo;

		/// The balance of an account.

		type Balance: Parameter

			+ Member

			+ AtLeast32BitUnsigned

			+ Codec

			+ Default

			+ Copy

			+ MaybeSerializeDeserialize

			+ Debug

			+ MaxEncodedLen

			+ TypeInfo

			+ FixedPointOperand;

		/// Handler for the unbalanced reduction when removing a dust account.

		#[pallet::no_default_bounds]

		type DustRemoval: OnUnbalanced<CreditOf<Self, I>>;

		/// The minimum amount required to keep an account open. MUST BE GREATER THAN ZERO!

		///

		/// If you *really* need it to be zero, you can enable the feature `insecure_zero_ed` for

		/// this pallet. However, you do so at your own risk: this will open up a major DoS vector.

		/// In case you have multiple sources of provider references, you may also get unexpected

		/// behaviour if you set this to zero.

		///

		/// Bottom line: Do yourself a favour and make it at least one!

		#[pallet::constant]

		#[pallet::no_default_bounds]

		type ExistentialDeposit: Get<Self::Balance>;

		/// The means of storing the balances of an account.

		#[pallet::no_default]

		type AccountStore: StoredMap<Self::AccountId, AccountData<Self::Balance>>;

		/// The ID type for reserves.

		///

		/// Use of reserves is deprecated in favour of holds. See `https://github.com/paritytech/substrate/pull/12951/`

		type ReserveIdentifier: Parameter + Member + MaxEncodedLen + Ord + Copy;

		/// The ID type for freezes.

		type FreezeIdentifier: Parameter + Member + MaxEncodedLen + Copy;

		/// The maximum number of locks that should exist on an account.

		/// Not strictly enforced, but used for weight estimation.

		///

		/// Use of locks is deprecated in favour of freezes. See `https://github.com/paritytech/substrate/pull/12951/`

		#[pallet::constant]

		type MaxLocks: Get<u32>;

		/// The maximum number of named reserves that can exist on an account.

		///

		/// Use of reserves is deprecated in favour of holds. See `https://github.com/paritytech/substrate/pull/12951/`

		#[pallet::constant]

		type MaxReserves: Get<u32>;

		/// The maximum number of individual freeze locks that can exist on an account at any time.

		#[pallet::constant]

		type MaxFreezes: Get<u32>;

	}

	/// The in-code storage version.

	const STORAGE_VERSION: frame_support::traits::StorageVersion =

		frame_support::traits::StorageVersion::new(1);

	#[pallet::storage_version(STORAGE_VERSION)]

	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);

	pub enum Event<T: Config<I>, I: 'static = ()> {

		/// resulting in an outright loss.

		/// Final argument indicates the destination balance type.

		ReserveRepatriated {

	}

	pub enum Error<T, I = ()> {

	}

	/// The total units issued in the system.

	#[pallet::getter(fn total_issuance)]

	#[pallet::whitelist_storage]

	pub type TotalIssuance<T: Config<I>, I: 'static = ()> = StorageValue<_, T::Balance, ValueQuery>;

	/// The total units of outstanding deactivated balance in the system.

	#[pallet::getter(fn inactive_issuance)]

	#[pallet::whitelist_storage]

	pub type InactiveIssuance<T: Config<I>, I: 'static = ()> =

		StorageValue<_, T::Balance, ValueQuery>;

	/// The Balances pallet example of storing the balance of an account.

	///

	/// # Example

	///

	/// ```nocompile

	///  impl pallet_balances::Config for Runtime {

	///    type AccountStore = StorageMapShim<Self::Account<Runtime>, frame_system::Provider<Runtime>, AccountId, Self::AccountData<Balance>>

	///  }

	/// ```

	///

	/// You can also store the balance of an account in the `System` pallet.

	///

	/// # Example

	///

	/// ```nocompile

	///  impl pallet_balances::Config for Runtime {

	///   type AccountStore = System

	///  }

	/// ```

	///

	/// But this comes with tradeoffs, storing account balances in the system pallet stores

	/// `frame_system` data alongside the account data contrary to storing account balances in the

	/// `Balances` pallet, which uses a `StorageMap` to store balances data only.

	/// NOTE: This is only used in the case that this pallet is used to store balances.

	pub type Account<T: Config<I>, I: 'static = ()> =

		StorageMap<_, Blake2_128Concat, T::AccountId, AccountData<T::Balance>, ValueQuery>;

	/// Any liquidity locks on some account balances.

	/// NOTE: Should only be accessed when setting, changing and freeing a lock.

	///

	/// Use of locks is deprecated in favour of freezes. See `https://github.com/paritytech/substrate/pull/12951/`

	#[pallet::getter(fn locks)]

	pub type Locks<T: Config<I>, I: 'static = ()> = StorageMap<

		_,

		Blake2_128Concat,

		T::AccountId,

		WeakBoundedVec<BalanceLock<T::Balance>, T::MaxLocks>,

		ValueQuery,

	>;

	/// Named reserves on some account balances.

	///

	/// Use of reserves is deprecated in favour of holds. See `https://github.com/paritytech/substrate/pull/12951/`

	#[pallet::getter(fn reserves)]

	pub type Reserves<T: Config<I>, I: 'static = ()> = StorageMap<

		_,

		Blake2_128Concat,

		T::AccountId,

		BoundedVec<ReserveData<T::ReserveIdentifier, T::Balance>, T::MaxReserves>,

		ValueQuery,

	>;

	/// Holds on account balances.

	pub type Holds<T: Config<I>, I: 'static = ()> = StorageMap<

		_,

		Blake2_128Concat,

		T::AccountId,

		BoundedVec<

			IdAmount<T::RuntimeHoldReason, T::Balance>,

			VariantCountOf<T::RuntimeHoldReason>,

		>,

		ValueQuery,

	>;

	/// Freeze locks on account balances.

	pub type Freezes<T: Config<I>, I: 'static = ()> = StorageMap<

		_,

		Blake2_128Concat,

		T::AccountId,

		BoundedVec<IdAmount<T::FreezeIdentifier, T::Balance>, T::MaxFreezes>,

		ValueQuery,

	>;

	#[pallet::genesis_config]

	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {

		pub balances: Vec<(T::AccountId, T::Balance)>,

	}

	impl<T: Config<I>, I: 'static> Default for GenesisConfig<T, I> {

	}

	impl<T: Config<I>, I: 'static> BuildGenesisConfig for GenesisConfig<T, I> {

				)

			}

			// ensure no duplicates exist.

			);

			}

	}

	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {

			);

			);

		#[cfg(feature = "try-runtime")]

				{

				} else {

				}

				} else {

				}

	}

	impl<T: Config<I>, I: 'static> Pallet<T, I> {

		/// Transfer some liquid free balance to another account.

		///

		/// `transfer_allow_death` will set the `FreeBalance` of the sender and receiver.

		/// If the sender's account is below the existential deposit as a result

		/// of the transfer, the account will be reaped.

		///

		/// The dispatch origin for this call must be `Signed` by the transactor.

		#[pallet::call_index(0)]

		pub fn transfer_allow_death(

			origin: OriginFor<T>,

			dest: AccountIdLookupOf<T>,

			#[pallet::compact] value: T::Balance,

		}

		/// Exactly as `transfer_allow_death`, except the origin must be root and the source account

		/// may be specified.

		#[pallet::call_index(2)]

		pub fn force_transfer(

			origin: OriginFor<T>,

			source: AccountIdLookupOf<T>,

			dest: AccountIdLookupOf<T>,

			#[pallet::compact] value: T::Balance,

		}

		/// Same as the [`transfer_allow_death`] call, but with a check that the transfer will not

		/// kill the origin account.

		///

		/// 99% of the time you want [`transfer_allow_death`] instead.

		///

		/// [`transfer_allow_death`]: struct.Pallet.html#method.transfer

		#[pallet::call_index(3)]

		pub fn transfer_keep_alive(

			origin: OriginFor<T>,

			dest: AccountIdLookupOf<T>,

			#[pallet::compact] value: T::Balance,

		}

		/// Transfer the entire transferable balance from the caller account.

		///

		/// NOTE: This function only attempts to transfer _transferable_ balances. This means that

		/// any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be

		/// transferred by this function. To ensure that this function results in a killed account,

		/// you might need to prepare the account by removing any reference counters, storage

		/// deposits, etc...

		///

		/// The dispatch origin of this call must be Signed.

		///

		/// - `dest`: The recipient of the transfer.

		/// - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all

		///   of the funds the account has, causing the sender account to be killed (false), or

		///   transfer everything except at least the existential deposit, which will guarantee to

		///   keep the sender account alive (true).

		#[pallet::call_index(4)]

		pub fn transfer_all(

			origin: OriginFor<T>,

			dest: AccountIdLookupOf<T>,

			keep_alive: bool,

		}

		/// Unreserve some balance from a user by force.

		///

		/// Can only be called by ROOT.

		#[pallet::call_index(5)]

		pub fn force_unreserve(

			origin: OriginFor<T>,

			who: AccountIdLookupOf<T>,

			amount: T::Balance,

		}

		/// Upgrade a specified account.

		///

		/// - `origin`: Must be `Signed`.

		/// - `who`: The account to be upgraded.

		///

		/// This will waive the transaction fee if at least all but 10% of the accounts needed to

		/// be upgraded. (We let some not have to be upgraded just in order to allow for the

		/// possibility of churn).

		#[pallet::call_index(6)]

		#[pallet::weight(T::WeightInfo::upgrade_accounts(who.len() as u32))]

		pub fn upgrade_accounts(

			origin: OriginFor<T>,

			who: Vec<T::AccountId>,

			}

			} else {

			}

		}

		/// Set the regular balance of a given account.

		///

		/// The dispatch origin for this call is `root`.

		#[pallet::call_index(8)]

		#[pallet::weight(

			T::WeightInfo::force_set_balance_creating() // Creates a new account.

				.max(T::WeightInfo::force_set_balance_killing()) // Kills an existing account.

		)]

		pub fn force_set_balance(

			origin: OriginFor<T>,

			who: AccountIdLookupOf<T>,

			#[pallet::compact] new_free: T::Balance,

			// First we try to modify the account's balance to the forced balance.

			// This will adjust the total issuance, which was not done by the `mutate_account`

			// above.

		}

		/// Adjust the total issuance in a saturating way.

		///

		/// Can only be called by root and always needs a positive `delta`.

		///

		/// # Example

		#[doc = docify::embed!("./src/tests/dispatchable_tests.rs", force_adjust_total_issuance_example)]

		#[pallet::call_index(9)]

		#[pallet::weight(T::WeightInfo::force_adjust_total_issuance())]

		pub fn force_adjust_total_issuance(

			origin: OriginFor<T>,

			direction: AdjustmentDirection,

			#[pallet::compact] delta: T::Balance,

			};

		}

		/// 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 and `keep_alive` is false, the account will be reaped.

		///

		/// Unlike sending funds to a _burn_ address, which merely makes the funds inaccessible,

		/// this `burn` operation will reduce total issuance by the amount _burned_.

		#[pallet::call_index(10)]

		#[pallet::weight(if *keep_alive {T::WeightInfo::burn_allow_death() } else {T::WeightInfo::burn_keep_alive()})]

		pub fn burn(

			origin: OriginFor<T>,

			#[pallet::compact] value: T::Balance,

			keep_alive: bool,

		}

	}

	impl<T: Config<I>, I: 'static> Pallet<T, I> {

		/// Ensure the account `who` is using the new logic.

		///

		/// Returns `true` if the account did get upgraded, `false` if it didn't need upgrading.

					// Gah!! We have no provider refs :(

					// This shouldn't practically happen, but we need a failsafe anyway: let's give

					// them enough for an ED.

						target: LOG_TARGET,

						who

					);

			// Should never fail - we're only setting a bit.

		/// Get the free balance of an account.

		/// 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`.

		/// 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`.

		///

		/// This requires that the account stays alive.

		/// Get the reserved balance of an account.

		/// Get both the free and reserved balances of an account.

		/// Mutate an account to some new value, or delete it entirely with `None`. Will enforce

		/// `ExistentialDeposit` law, annulling the account as needed.

		///

		/// It returns the result from the closure. Any dust is handled through the low-level

		/// `fungible::Unbalanced` trap-door for legacy dust management.

		///

		/// NOTE: Doesn't do any preparatory work for creating a new account, so should only be used

		/// when it is known that the account already exists.

		///

		/// NOTE: LOW-LEVEL: This will not attempt to maintain total issuance. It is expected that

		/// the caller will do this.

		/// Mutate an account to some new value, or delete it entirely with `None`. Will enforce

		/// `ExistentialDeposit` law, annulling the account as needed.

		///

		/// It returns the result from the closure. Any dust is handled through the low-level

		/// `fungible::Unbalanced` trap-door for legacy dust management.

		///

		/// NOTE: Doesn't do any preparatory work for creating a new account, so should only be used

		/// when it is known that the account already exists.

		///

		/// NOTE: LOW-LEVEL: This will not attempt to maintain total issuance. It is expected that

		/// the caller will do this.

		/// Mutate an account to some new value, or delete it entirely with `None`. Will enforce

		/// `ExistentialDeposit` law, annulling the account as needed.

		///

		/// It returns both the result from the closure, and an optional amount of dust

		/// which should be handled once it is known that all nested mutates that could affect

		/// storage items what the dust handler touches have completed.

		///

		/// NOTE: Doesn't do any preparatory work for creating a new account, so should only be used

		/// when it is known that the account already exists.

		///

		/// NOTE: LOW-LEVEL: This will not attempt to maintain total issuance. It is expected that

		/// the caller will do this.

		/// Returns `true` when `who` has some providers or `insecure_zero_ed` feature is disabled.

		/// Returns `false` otherwise.

		#[cfg(not(feature = "insecure_zero_ed"))]

		/// Returns `true` when `who` has some providers or `insecure_zero_ed` feature is disabled.

		/// Returns `false` otherwise.

		#[cfg(feature = "insecure_zero_ed")]

		fn have_providers_or_no_zero_ed(who: &T::AccountId) -> bool {

			frame_system::Pallet::<T>::providers(who) > 0

		}

		/// Mutate an account to some new value, or delete it entirely with `None`. Will enforce

		/// `ExistentialDeposit` law, annulling the account as needed. This will do nothing if the

		/// result of `f` is an `Err`.

		///

		/// It returns both the result from the closure, and an optional amount of dust

		/// which should be handled once it is known that all nested mutates that could affect

		/// storage items what the dust handler touches have completed.

		///

		/// NOTE: Doesn't do any preparatory work for creating a new account, so should only be used

		/// when it is known that the account already exists.

		///

		/// NOTE: LOW-LEVEL: This will not attempt to maintain total issuance. It is expected that

		/// the caller will do this.

					// NOTE: This is a failsafe and should not happen for normal accounts. A normal

					// account should have gotten a consumer ref in `!did_consume && does_consume`

					// at some point.

					// This could reap the account so must go last.

				// Handle any steps needed after mutating an account.

				//

				// This includes DustRemoval unbalancing, in the case than the `new` account's total

				// balance is non-zero but below ED.

				//

				// Updates `maybe_account` to `Some` iff the account has sufficient balance.

				// Evaluates `maybe_dust`, which is `Some` containing the dust to be dropped, iff

				// some dust should be dropped.

				//

				// We should never be dropping if reserved is non-zero. Reserved being non-zero

				// should imply that we have a consumer ref, so this is economically safe.

					} else {

					}

				} else {

					);

				};

		/// Update the account entry for `who`, given the locks.

					target: LOG_TARGET,

				);

			}

		/// Update the account entry for `who`, given the locks.

		/// Move the reserved balance of one account into the balance of another, according to

		/// `status`. This will respect freezes/locks only if `fortitude` is `Polite`.

		///

		/// Is a no-op if the value to be moved is zero.

		///

		/// NOTE: returns actual amount of transferred value in `Ok` case.

			};

				}

							Status::Free =>

							Status::Reserved =>

						}

	}

}