Type Alias pallet_quota::pallet::CurrencyOf
source · pub type CurrencyOf<T> = Pallet<T>;
Aliased Type§
struct CurrencyOf<T>(PhantomData<(T, ())>);
Fields§
§0: PhantomData<(T, ())>
Implementations
§impl<T, I> Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> Pallet<T, I>where
T: Config<I>,
I: 'static,
pub fn ensure_upgraded(who: &<T as Config>::AccountId) -> bool
pub fn ensure_upgraded(who: &<T as Config>::AccountId) -> bool
Ensure the account who
is using the new logic.
Returns true
if the account did get upgraded, false
if it didn’t need upgrading.
pub fn free_balance(
who: impl Borrow<<T as Config>::AccountId>
) -> <T as Config<I>>::Balance
pub fn free_balance( who: impl Borrow<<T as Config>::AccountId> ) -> <T as Config<I>>::Balance
Get the free balance of an account.
pub fn usable_balance(
who: impl Borrow<<T as Config>::AccountId>
) -> <T as Config<I>>::Balance
pub fn usable_balance( who: impl Borrow<<T as Config>::AccountId> ) -> <T as Config<I>>::Balance
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
.
pub fn usable_balance_for_fees(
who: impl Borrow<<T as Config>::AccountId>
) -> <T as Config<I>>::Balance
pub fn usable_balance_for_fees( who: impl Borrow<<T as Config>::AccountId> ) -> <T as Config<I>>::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.
pub fn reserved_balance(
who: impl Borrow<<T as Config>::AccountId>
) -> <T as Config<I>>::Balance
pub fn reserved_balance( who: impl Borrow<<T as Config>::AccountId> ) -> <T as Config<I>>::Balance
Get the reserved balance of an account.
§impl<T, I> Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> Pallet<T, I>where
T: Config<I>,
I: 'static,
pub fn inactive_issuance() -> <T as Config<I>>::Balance
pub fn inactive_issuance() -> <T as Config<I>>::Balance
An auto-generated getter for [InactiveIssuance
].
§impl<T, I> Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> Pallet<T, I>where
T: Config<I>,
I: 'static,
pub fn locks<KArg>(
k: KArg
) -> WeakBoundedVec<BalanceLock<<T as Config<I>>::Balance>, <T as Config<I>>::MaxLocks>where
KArg: EncodeLike<<T as Config>::AccountId>,
pub fn locks<KArg>(
k: KArg
) -> WeakBoundedVec<BalanceLock<<T as Config<I>>::Balance>, <T as Config<I>>::MaxLocks>where
KArg: EncodeLike<<T as Config>::AccountId>,
An auto-generated getter for [Locks
].
§impl<T, I> Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> Pallet<T, I>where
T: Config<I>,
I: 'static,
pub fn reserves<KArg>(
k: KArg
) -> BoundedVec<ReserveData<<T as Config<I>>::ReserveIdentifier, <T as Config<I>>::Balance>, <T as Config<I>>::MaxReserves>where
KArg: EncodeLike<<T as Config>::AccountId>,
pub fn reserves<KArg>(
k: KArg
) -> BoundedVec<ReserveData<<T as Config<I>>::ReserveIdentifier, <T as Config<I>>::Balance>, <T as Config<I>>::MaxReserves>where
KArg: EncodeLike<<T as Config>::AccountId>,
An auto-generated getter for [Reserves
].
§impl<T, I> Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> Pallet<T, I>where
T: Config<I>,
I: 'static,
pub fn total_issuance() -> <T as Config<I>>::Balance
pub fn total_issuance() -> <T as Config<I>>::Balance
An auto-generated getter for [TotalIssuance
].
§impl<T, I> Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> Pallet<T, I>where
T: Config<I>,
I: 'static,
pub fn transfer_allow_death(
origin: <T as Config>::RuntimeOrigin,
dest: <<T as Config>::Lookup as StaticLookup>::Source,
value: <T as Config<I>>::Balance
) -> Result<(), DispatchError>
pub fn transfer_allow_death( origin: <T as Config>::RuntimeOrigin, dest: <<T as Config>::Lookup as StaticLookup>::Source, value: <T as Config<I>>::Balance ) -> Result<(), DispatchError>
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.
pub fn force_transfer(
origin: <T as Config>::RuntimeOrigin,
source: <<T as Config>::Lookup as StaticLookup>::Source,
dest: <<T as Config>::Lookup as StaticLookup>::Source,
value: <T as Config<I>>::Balance
) -> Result<(), DispatchError>
pub fn force_transfer( origin: <T as Config>::RuntimeOrigin, source: <<T as Config>::Lookup as StaticLookup>::Source, dest: <<T as Config>::Lookup as StaticLookup>::Source, value: <T as Config<I>>::Balance ) -> Result<(), DispatchError>
Exactly as transfer_allow_death
, except the origin must be root and the source account
may be specified.
pub fn transfer_keep_alive(
origin: <T as Config>::RuntimeOrigin,
dest: <<T as Config>::Lookup as StaticLookup>::Source,
value: <T as Config<I>>::Balance
) -> Result<(), DispatchError>
pub fn transfer_keep_alive( origin: <T as Config>::RuntimeOrigin, dest: <<T as Config>::Lookup as StaticLookup>::Source, value: <T as Config<I>>::Balance ) -> Result<(), DispatchError>
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.
pub fn transfer_all(
origin: <T as Config>::RuntimeOrigin,
dest: <<T as Config>::Lookup as StaticLookup>::Source,
keep_alive: bool
) -> Result<(), DispatchError>
pub fn transfer_all( origin: <T as Config>::RuntimeOrigin, dest: <<T as Config>::Lookup as StaticLookup>::Source, keep_alive: bool ) -> Result<(), DispatchError>
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 thetransfer_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).
pub fn force_unreserve(
origin: <T as Config>::RuntimeOrigin,
who: <<T as Config>::Lookup as StaticLookup>::Source,
amount: <T as Config<I>>::Balance
) -> Result<(), DispatchError>
pub fn force_unreserve( origin: <T as Config>::RuntimeOrigin, who: <<T as Config>::Lookup as StaticLookup>::Source, amount: <T as Config<I>>::Balance ) -> Result<(), DispatchError>
Unreserve some balance from a user by force.
Can only be called by ROOT.
pub fn force_set_balance(
origin: <T as Config>::RuntimeOrigin,
who: <<T as Config>::Lookup as StaticLookup>::Source,
new_free: <T as Config<I>>::Balance
) -> Result<(), DispatchError>
pub fn force_set_balance( origin: <T as Config>::RuntimeOrigin, who: <<T as Config>::Lookup as StaticLookup>::Source, new_free: <T as Config<I>>::Balance ) -> Result<(), DispatchError>
Upgrade a specified account.
origin
: Must beSigned
.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 possibililty of churn). Set the regular balance of a given account.
The dispatch origin for this call is root
.
pub fn force_adjust_total_issuance(
origin: <T as Config>::RuntimeOrigin,
direction: AdjustmentDirection,
delta: <T as Config<I>>::Balance
) -> Result<(), DispatchError>
pub fn force_adjust_total_issuance( origin: <T as Config>::RuntimeOrigin, direction: AdjustmentDirection, delta: <T as Config<I>>::Balance ) -> Result<(), DispatchError>
Adjust the total issuance in a saturating way.
Can only be called by root and always needs a positive delta
.
§Example
#[test]
fn force_adjust_total_issuance_example() {
ExtBuilder::default().build_and_execute_with(|| {
// First we set the TotalIssuance to 64 by giving Alice a balance of 64.
assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), ALICE, 64));
let old_ti = Balances::total_issuance();
assert_eq!(old_ti, 64, "TI should be 64");
// Now test the increase:
assert_ok!(Balances::force_adjust_total_issuance(RawOrigin::Root.into(), Inc, 32));
let new_ti = Balances::total_issuance();
assert_eq!(old_ti + 32, new_ti, "Should increase by 32");
// If Alice tries to call it, it errors:
assert_noop!(
Balances::force_adjust_total_issuance(RawOrigin::Signed(ALICE).into(), Inc, 32),
BadOrigin,
);
});
}
Trait Implementations
§impl<T, I> AccountTouch<(), <T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> AccountTouch<(), <T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
§fn deposit_required(
_: ()
) -> <Pallet<T, I> as AccountTouch<(), <T as Config>::AccountId>>::Balance
fn deposit_required( _: () ) -> <Pallet<T, I> as AccountTouch<(), <T as Config>::AccountId>>::Balance
asset
.§fn should_touch(_: (), _: &<T as Config>::AccountId) -> bool
fn should_touch(_: (), _: &<T as Config>::AccountId) -> bool
§impl<T, I> Balanced<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> Balanced<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
§type OnDropCredit = DecreaseIssuance<<T as Config>::AccountId, Pallet<T, I>>
type OnDropCredit = DecreaseIssuance<<T as Config>::AccountId, Pallet<T, I>>
Credit
is dropped without being
used.§type OnDropDebt = IncreaseIssuance<<T as Config>::AccountId, Pallet<T, I>>
type OnDropDebt = IncreaseIssuance<<T as Config>::AccountId, Pallet<T, I>>
Debt
is dropped without being used.fn done_deposit( who: &<T as Config>::AccountId, amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance )
fn done_withdraw( who: &<T as Config>::AccountId, amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance )
fn done_issue( amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance )
fn done_rescind( amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance )
§fn rescind(
amount: Self::Balance
) -> Imbalance<Self::Balance, Self::OnDropDebt, Self::OnDropCredit>
fn rescind( amount: Self::Balance ) -> Imbalance<Self::Balance, Self::OnDropDebt, Self::OnDropCredit>
amount
and return the according imbalance. The imbalance will
typically be used to reduce an account by the same amount with e.g. [Balanced::settle
]. Read more§fn issue(
amount: Self::Balance
) -> Imbalance<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>
fn issue( amount: Self::Balance ) -> Imbalance<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>
amount
and return the according imbalance. The imbalance
will typically be used to increase an account by the same amount with e.g.
[Balanced::resolve
]. Read more§fn pair(
amount: Self::Balance
) -> Result<(Imbalance<Self::Balance, Self::OnDropDebt, Self::OnDropCredit>, Imbalance<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>), DispatchError>
fn pair( amount: Self::Balance ) -> Result<(Imbalance<Self::Balance, Self::OnDropDebt, Self::OnDropCredit>, Imbalance<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>), DispatchError>
§fn deposit(
who: &AccountId,
value: Self::Balance,
precision: Precision
) -> Result<Imbalance<Self::Balance, Self::OnDropDebt, Self::OnDropCredit>, DispatchError>
fn deposit( who: &AccountId, value: Self::Balance, precision: Precision ) -> Result<Imbalance<Self::Balance, Self::OnDropDebt, Self::OnDropCredit>, DispatchError>
§fn withdraw(
who: &AccountId,
value: Self::Balance,
precision: Precision,
preservation: Preservation,
force: Fortitude
) -> Result<Imbalance<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>, DispatchError>
fn withdraw( who: &AccountId, value: Self::Balance, precision: Precision, preservation: Preservation, force: Fortitude ) -> Result<Imbalance<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>, DispatchError>
§fn resolve(
who: &AccountId,
credit: Imbalance<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>
) -> Result<(), Imbalance<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>>
fn resolve( who: &AccountId, credit: Imbalance<Self::Balance, Self::OnDropCredit, Self::OnDropDebt> ) -> Result<(), Imbalance<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>>
who
is increased in order to counter credit
. If the whole of credit
cannot be countered, then nothing is changed and the original credit
is returned in an
Err
. Read more§fn settle(
who: &AccountId,
debt: Imbalance<Self::Balance, Self::OnDropDebt, Self::OnDropCredit>,
preservation: Preservation
) -> Result<Imbalance<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>, Imbalance<Self::Balance, Self::OnDropDebt, Self::OnDropCredit>>
fn settle( who: &AccountId, debt: Imbalance<Self::Balance, Self::OnDropDebt, Self::OnDropCredit>, preservation: Preservation ) -> Result<Imbalance<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>, Imbalance<Self::Balance, Self::OnDropDebt, Self::OnDropCredit>>
who
is decreased in order to counter debt
. If the whole of debt
cannot be countered, then nothing is changed and the original debt
is returned in an
Err
.§impl<T, I> Balanced<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> Balanced<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
§fn slash(
reason: &Self::Reason,
who: &AccountId,
amount: Self::Balance
) -> (Imbalance<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>, Self::Balance)
fn slash( reason: &Self::Reason, who: &AccountId, amount: Self::Balance ) -> (Imbalance<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>, Self::Balance)
fn done_slash(_reason: &Self::Reason, _who: &AccountId, _amount: Self::Balance)
§impl<T, I> BeforeAllRuntimeMigrations for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> BeforeAllRuntimeMigrations for Pallet<T, I>where
T: Config<I>,
I: 'static,
§fn before_all_runtime_migrations() -> Weight
fn before_all_runtime_migrations() -> Weight
§impl<T, I> Benchmarking for Pallet<T, I>where
T: Config<I> + Config,
I: 'static,
impl<T, I> Benchmarking for Pallet<T, I>where
T: Config<I> + Config,
I: 'static,
§fn benchmarks(extra: bool) -> Vec<BenchmarkMetadata>
fn benchmarks(extra: bool) -> Vec<BenchmarkMetadata>
§impl<T, I> Callable<T> for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> Callable<T> for Pallet<T, I>where
T: Config<I>,
I: 'static,
type RuntimeCall = Call<T, I>
§impl<T, I> Currency<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
<T as Config<I>>::Balance: MaybeSerializeDeserialize + Debug,
impl<T, I> Currency<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
<T as Config<I>>::Balance: MaybeSerializeDeserialize + Debug,
§fn slash(
who: &<T as Config>::AccountId,
value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
) -> (<Pallet<T, I> as Currency<<T as Config>::AccountId>>::NegativeImbalance, <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance)
fn slash( who: &<T as Config>::AccountId, value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance ) -> (<Pallet<T, I> as Currency<<T as Config>::AccountId>>::NegativeImbalance, <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance)
Slash a target account who
, returning the negative imbalance created and any left over
amount that could not be slashed.
Is a no-op if value
to be slashed is zero or the account does not exist.
NOTE: slash()
prefers free balance, but assumes that reserve balance can be drawn
from in extreme circumstances. can_slash()
should be used prior to slash()
to avoid
having to draw from reserved funds, however we err on the side of punishment if things are
inconsistent or can_slash
wasn’t used appropriately.
§fn deposit_into_existing(
who: &<T as Config>::AccountId,
value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
) -> Result<<Pallet<T, I> as Currency<<T as Config>::AccountId>>::PositiveImbalance, DispatchError>
fn deposit_into_existing( who: &<T as Config>::AccountId, value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance ) -> Result<<Pallet<T, I> as Currency<<T as Config>::AccountId>>::PositiveImbalance, DispatchError>
Deposit some value
into the free balance of an existing target account who
.
Is a no-op if the value
to be deposited is zero.
§fn deposit_creating(
who: &<T as Config>::AccountId,
value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::PositiveImbalance
fn deposit_creating( who: &<T as Config>::AccountId, value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance ) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::PositiveImbalance
Deposit some value
into the free balance of who
, possibly creating a new account.
This function is a no-op if:
- the
value
to be deposited is zero; or - the
value
to be deposited is less than the required ED and the account does not yet exist; or - the deposit would necessitate the account to exist and there are no provider references; or
value
is so large it would cause the balance ofwho
to overflow.
§fn withdraw(
who: &<T as Config>::AccountId,
value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance,
reasons: WithdrawReasons,
liveness: ExistenceRequirement
) -> Result<<Pallet<T, I> as Currency<<T as Config>::AccountId>>::NegativeImbalance, DispatchError>
fn withdraw( who: &<T as Config>::AccountId, value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance, reasons: WithdrawReasons, liveness: ExistenceRequirement ) -> Result<<Pallet<T, I> as Currency<<T as Config>::AccountId>>::NegativeImbalance, DispatchError>
Withdraw some free balance from an account, respecting existence requirements.
Is a no-op if value to be withdrawn is zero.
§fn make_free_balance_be(
who: &<T as Config>::AccountId,
value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
) -> SignedImbalance<<Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance, <Pallet<T, I> as Currency<<T as Config>::AccountId>>::PositiveImbalance>
fn make_free_balance_be( who: &<T as Config>::AccountId, value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance ) -> SignedImbalance<<Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance, <Pallet<T, I> as Currency<<T as Config>::AccountId>>::PositiveImbalance>
Force the new free balance of a target account who
to some new value balance
.
§type PositiveImbalance = PositiveImbalance<T, I>
type PositiveImbalance = PositiveImbalance<T, I>
§type NegativeImbalance = NegativeImbalance<T, I>
type NegativeImbalance = NegativeImbalance<T, I>
§fn total_balance(
who: &<T as Config>::AccountId
) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
fn total_balance( who: &<T as Config>::AccountId ) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
who
.§fn can_slash(
who: &<T as Config>::AccountId,
value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
) -> bool
fn can_slash( who: &<T as Config>::AccountId, value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance ) -> bool
slash(who, value)
(but without the side-effects) assuming there are no
balance changes in the meantime and only the reserved balance is not taken into account.§fn total_issuance(
) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
fn total_issuance( ) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
§fn active_issuance(
) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
fn active_issuance( ) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
§fn deactivate(
amount: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
)
fn deactivate( amount: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance )
§fn reactivate(
amount: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
)
fn reactivate( amount: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance )
§fn minimum_balance(
) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
fn minimum_balance( ) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
Balances
module’s ExistentialDeposit
.§fn burn(
amount: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::PositiveImbalance
fn burn( amount: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance ) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::PositiveImbalance
amount
and return the according imbalance. The imbalance will
typically be used to reduce an account by the same amount with e.g. settle
. Read more§fn issue(
amount: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::NegativeImbalance
fn issue( amount: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance ) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::NegativeImbalance
amount
and return the according imbalance. The imbalance
will typically be used to increase an account by the same amount with e.g.
resolve_into_existing
or resolve_creating
. Read more§fn free_balance(
who: &<T as Config>::AccountId
) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
fn free_balance( who: &<T as Config>::AccountId ) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
§fn ensure_can_withdraw(
who: &<T as Config>::AccountId,
amount: <T as Config<I>>::Balance,
_reasons: WithdrawReasons,
new_balance: <T as Config<I>>::Balance
) -> Result<(), DispatchError>
fn ensure_can_withdraw( who: &<T as Config>::AccountId, amount: <T as Config<I>>::Balance, _reasons: WithdrawReasons, new_balance: <T as Config<I>>::Balance ) -> Result<(), DispatchError>
Ok
iff the account is able to make a withdrawal of the given amount
for the given reason. Basically, it’s just a dry-run of withdraw
. Read more§fn transfer(
transactor: &<T as Config>::AccountId,
dest: &<T as Config>::AccountId,
value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance,
existence_requirement: ExistenceRequirement
) -> Result<(), DispatchError>
fn transfer( transactor: &<T as Config>::AccountId, dest: &<T as Config>::AccountId, value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance, existence_requirement: ExistenceRequirement ) -> Result<(), DispatchError>
§fn pair(
amount: Self::Balance
) -> (Self::PositiveImbalance, Self::NegativeImbalance)
fn pair( amount: Self::Balance ) -> (Self::PositiveImbalance, Self::NegativeImbalance)
§fn resolve_into_existing(
who: &AccountId,
value: Self::NegativeImbalance
) -> Result<(), Self::NegativeImbalance>
fn resolve_into_existing( who: &AccountId, value: Self::NegativeImbalance ) -> Result<(), Self::NegativeImbalance>
NegativeImbalance
and returns nothing on
success.§fn resolve_creating(who: &AccountId, value: Self::NegativeImbalance)
fn resolve_creating(who: &AccountId, value: Self::NegativeImbalance)
NegativeImbalance
and returns nothing on
success.§fn settle(
who: &AccountId,
value: Self::PositiveImbalance,
reasons: WithdrawReasons,
liveness: ExistenceRequirement
) -> Result<(), Self::PositiveImbalance>
fn settle( who: &AccountId, value: Self::PositiveImbalance, reasons: WithdrawReasons, liveness: ExistenceRequirement ) -> Result<(), Self::PositiveImbalance>
PositiveImbalance
and returns nothing on success.§impl<T, I> GetStorageVersion for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> GetStorageVersion for Pallet<T, I>where
T: Config<I>,
I: 'static,
§type InCodeStorageVersion = StorageVersion
type InCodeStorageVersion = StorageVersion
§fn in_code_storage_version(
) -> <Pallet<T, I> as GetStorageVersion>::InCodeStorageVersion
fn in_code_storage_version( ) -> <Pallet<T, I> as GetStorageVersion>::InCodeStorageVersion
storage_version
attribute, or
[NoStorageVersionSet
] if the attribute is missing.§fn on_chain_storage_version() -> StorageVersion
fn on_chain_storage_version() -> StorageVersion
§fn current_storage_version() -> Self::InCodeStorageVersion
fn current_storage_version() -> Self::InCodeStorageVersion
in_code_storage_version
and will be removed after March 2024.Self::current_storage_version
] instead. Read more§impl<T, I> Hooks<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> Hooks<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T, I>where
T: Config<I>,
I: 'static,
§fn integrity_test()
fn integrity_test()
§fn on_initialize(_n: BlockNumber) -> Weight
fn on_initialize(_n: BlockNumber) -> Weight
§fn on_finalize(_n: BlockNumber)
fn on_finalize(_n: BlockNumber)
§fn on_idle(_n: BlockNumber, _remaining_weight: Weight) -> Weight
fn on_idle(_n: BlockNumber, _remaining_weight: Weight) -> Weight
Hooks::on_finalize
]). Read more§fn on_poll(_n: BlockNumber, _weight: &mut WeightMeter)
fn on_poll(_n: BlockNumber, _weight: &mut WeightMeter)
§fn on_runtime_upgrade() -> Weight
fn on_runtime_upgrade() -> Weight
Executive
pallet. Read more§fn offchain_worker(_n: BlockNumber)
fn offchain_worker(_n: BlockNumber)
§impl<T, I> Inspect<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> Inspect<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
§fn total_issuance(
) -> <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance
fn total_issuance( ) -> <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance
§fn active_issuance(
) -> <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance
fn active_issuance( ) -> <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance
§fn minimum_balance(
) -> <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance
fn minimum_balance( ) -> <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance
§fn total_balance(
who: &<T as Config>::AccountId
) -> <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance
fn total_balance( who: &<T as Config>::AccountId ) -> <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance
who
. Read more§fn balance(
who: &<T as Config>::AccountId
) -> <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance
fn balance( who: &<T as Config>::AccountId ) -> <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance
who
which does not include funds which are exclusively allocated to
subsystems of the chain (“on hold” or “reserved”). Read more§fn reducible_balance(
who: &<T as Config>::AccountId,
preservation: Preservation,
force: Fortitude
) -> <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance
fn reducible_balance( who: &<T as Config>::AccountId, preservation: Preservation, force: Fortitude ) -> <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance
who
can withdraw/transfer successfully based on whether the
account should be kept alive (preservation
) or whether we are willing to force the
reduction and potentially go below user-level restrictions on the minimum amount of the
account. Read more§fn can_deposit(
who: &<T as Config>::AccountId,
amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance,
provenance: Provenance
) -> DepositConsequence
fn can_deposit( who: &<T as Config>::AccountId, amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance, provenance: Provenance ) -> DepositConsequence
§fn can_withdraw(
who: &<T as Config>::AccountId,
amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance
) -> WithdrawConsequence<<Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance>
fn can_withdraw( who: &<T as Config>::AccountId, amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance ) -> WithdrawConsequence<<Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance>
Success
if the balance of who
may be decreased by amount
, otherwise
the consequence.§impl<T, I> Inspect<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> Inspect<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
§fn balance_frozen(
id: &<Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Id,
who: &<T as Config>::AccountId
) -> <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance
fn balance_frozen( id: &<Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Id, who: &<T as Config>::AccountId ) -> <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance
who
for the given id
.§fn can_freeze(
id: &<Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Id,
who: &<T as Config>::AccountId
) -> bool
fn can_freeze( id: &<Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Id, who: &<T as Config>::AccountId ) -> bool
true
if it’s possible to introduce a freeze for the given id
onto the
account of who
. This will be true as long as the implementor supports as many
concurrent freeze locks as there are possible values of id
.§fn balance_freezable(who: &AccountId) -> Self::Balance
fn balance_freezable(who: &AccountId) -> Self::Balance
total_balance()
.§impl<T, I> Inspect<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> Inspect<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
§type Reason = <T as Config<I>>::RuntimeHoldReason
type Reason = <T as Config<I>>::RuntimeHoldReason
§fn total_balance_on_hold(
who: &<T as Config>::AccountId
) -> <T as Config<I>>::Balance
fn total_balance_on_hold( who: &<T as Config>::AccountId ) -> <T as Config<I>>::Balance
who
.§fn reducible_total_balance_on_hold(
who: &<T as Config>::AccountId,
force: Fortitude
) -> <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance
fn reducible_total_balance_on_hold( who: &<T as Config>::AccountId, force: Fortitude ) -> <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance
total_balance_on_hold
of who
can be reduced successfully
based on whether we are willing to force the reduction and potentially go below user-level
restrictions on the minimum amount of the account. Note: This cannot bring the account into
an inconsistent state with regards any required existential deposit. Read more§fn balance_on_hold(
reason: &<Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Reason,
who: &<T as Config>::AccountId
) -> <T as Config<I>>::Balance
fn balance_on_hold( reason: &<Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Reason, who: &<T as Config>::AccountId ) -> <T as Config<I>>::Balance
who
.§fn hold_available(
reason: &<Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Reason,
who: &<T as Config>::AccountId
) -> bool
fn hold_available( reason: &<Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Reason, who: &<T as Config>::AccountId ) -> bool
true
if it’s possible to place (additional) funds under a hold of a given
reason
. This may fail if the account has exhausted a limited number of concurrent
holds or if it cannot be made to exist (e.g. there is no provider reference). Read more§fn ensure_can_hold(
reason: &Self::Reason,
who: &AccountId,
amount: Self::Balance
) -> Result<(), DispatchError>
fn ensure_can_hold( reason: &Self::Reason, who: &AccountId, amount: Self::Balance ) -> Result<(), DispatchError>
amount
of funds of who
may be placed on hold with the given
reason
. Reasons why this may not be true: Read more§fn can_hold(
reason: &Self::Reason,
who: &AccountId,
amount: Self::Balance
) -> bool
fn can_hold( reason: &Self::Reason, who: &AccountId, amount: Self::Balance ) -> bool
amount
of funds of who
may be placed on hold for the given
reason
. Reasons why this may not be true: Read more§impl<T, I> IntegrityTest for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> IntegrityTest for Pallet<T, I>where
T: Config<I>,
I: 'static,
§fn integrity_test()
fn integrity_test()
Hooks::integrity_test
].§impl<T, I> LockableCurrency<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
<T as Config<I>>::Balance: MaybeSerializeDeserialize + Debug,
impl<T, I> LockableCurrency<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
<T as Config<I>>::Balance: MaybeSerializeDeserialize + Debug,
§type Moment = <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number
type Moment = <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number
BlockNumber
.§type MaxLocks = <T as Config<I>>::MaxLocks
type MaxLocks = <T as Config<I>>::MaxLocks
§fn set_lock(
id: [u8; 8],
who: &<T as Config>::AccountId,
amount: <T as Config<I>>::Balance,
reasons: WithdrawReasons
)
fn set_lock( id: [u8; 8], who: &<T as Config>::AccountId, amount: <T as Config<I>>::Balance, reasons: WithdrawReasons )
who
. Read more§fn extend_lock(
id: [u8; 8],
who: &<T as Config>::AccountId,
amount: <T as Config<I>>::Balance,
reasons: WithdrawReasons
)
fn extend_lock( id: [u8; 8], who: &<T as Config>::AccountId, amount: <T as Config<I>>::Balance, reasons: WithdrawReasons )
id
) so that it becomes less liquid in all
parameters or creates a new one if it does not exist. Read more§fn remove_lock(id: [u8; 8], who: &<T as Config>::AccountId)
fn remove_lock(id: [u8; 8], who: &<T as Config>::AccountId)
§impl<T, I> Mutate<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> Mutate<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
fn done_mint_into( who: &<T as Config>::AccountId, amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance )
fn done_burn_from( who: &<T as Config>::AccountId, amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance )
fn done_shelve( who: &<T as Config>::AccountId, amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance )
fn done_restore( who: &<T as Config>::AccountId, amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance )
fn done_transfer( source: &<T as Config>::AccountId, dest: &<T as Config>::AccountId, amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance )
§fn mint_into(
who: &AccountId,
amount: Self::Balance
) -> Result<Self::Balance, DispatchError>
fn mint_into( who: &AccountId, amount: Self::Balance ) -> Result<Self::Balance, DispatchError>
who
by exactly amount
, minting new tokens. If that isn’t
possible then an Err
is returned and nothing is changed.§fn burn_from(
who: &AccountId,
amount: Self::Balance,
precision: Precision,
force: Fortitude
) -> Result<Self::Balance, DispatchError>
fn burn_from( who: &AccountId, amount: Self::Balance, precision: Precision, force: Fortitude ) -> Result<Self::Balance, DispatchError>
who
by at least amount
, possibly slightly more in the case of
minimum-balance requirements, burning the tokens. If that isn’t possible then an Err
is
returned and nothing is changed. If successful, the amount of tokens reduced is returned.§fn shelve(
who: &AccountId,
amount: Self::Balance
) -> Result<Self::Balance, DispatchError>
fn shelve( who: &AccountId, amount: Self::Balance ) -> Result<Self::Balance, DispatchError>
§fn restore(
who: &AccountId,
amount: Self::Balance
) -> Result<Self::Balance, DispatchError>
fn restore( who: &AccountId, amount: Self::Balance ) -> Result<Self::Balance, DispatchError>
§fn transfer(
source: &AccountId,
dest: &AccountId,
amount: Self::Balance,
preservation: Preservation
) -> Result<Self::Balance, DispatchError>
fn transfer( source: &AccountId, dest: &AccountId, amount: Self::Balance, preservation: Preservation ) -> Result<Self::Balance, DispatchError>
§fn set_balance(who: &AccountId, amount: Self::Balance) -> Self::Balance
fn set_balance(who: &AccountId, amount: Self::Balance) -> Self::Balance
§impl<T, I> Mutate<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> Mutate<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
§fn set_freeze(
id: &<Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Id,
who: &<T as Config>::AccountId,
amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance
) -> Result<(), DispatchError>
fn set_freeze( id: &<Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Id, who: &<T as Config>::AccountId, amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance ) -> Result<(), DispatchError>
who
below the given
amount
and identify this restriction though the given id
. Unlike extend_freeze
, any
outstanding freeze in place for who
under the id
are dropped. Read more§fn extend_freeze(
id: &<Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Id,
who: &<T as Config>::AccountId,
amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance
) -> Result<(), DispatchError>
fn extend_freeze( id: &<Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Id, who: &<T as Config>::AccountId, amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance ) -> Result<(), DispatchError>
who
from being reduced below the given amount
and
identify this restriction though the given id
. Unlike set_freeze
, this does not
counteract any pre-existing freezes in place for who
under the id
. Also unlike
set_freeze
, in the case that amount
is zero, this is no-op and never fails. Read more§fn thaw(
id: &<Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Id,
who: &<T as Config>::AccountId
) -> Result<(), DispatchError>
fn thaw( id: &<Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Id, who: &<T as Config>::AccountId ) -> Result<(), DispatchError>
§fn set_frozen(
id: &Self::Id,
who: &AccountId,
amount: Self::Balance,
fortitude: Fortitude
) -> Result<(), DispatchError>
fn set_frozen( id: &Self::Id, who: &AccountId, amount: Self::Balance, fortitude: Fortitude ) -> Result<(), DispatchError>
§fn ensure_frozen(
id: &Self::Id,
who: &AccountId,
amount: Self::Balance,
fortitude: Fortitude
) -> Result<(), DispatchError>
fn ensure_frozen( id: &Self::Id, who: &AccountId, amount: Self::Balance, fortitude: Fortitude ) -> Result<(), DispatchError>
id
to amount
, iff this would increase
the amount frozen under id
. Do nothing otherwise. Read more§fn decrease_frozen(
id: &Self::Id,
who: &AccountId,
amount: Self::Balance
) -> Result<(), DispatchError>
fn decrease_frozen( id: &Self::Id, who: &AccountId, amount: Self::Balance ) -> Result<(), DispatchError>
§fn increase_frozen(
id: &Self::Id,
who: &AccountId,
amount: Self::Balance
) -> Result<(), DispatchError>
fn increase_frozen( id: &Self::Id, who: &AccountId, amount: Self::Balance ) -> Result<(), DispatchError>
§impl<T, I> Mutate<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> Mutate<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
§fn hold(
reason: &Self::Reason,
who: &AccountId,
amount: Self::Balance
) -> Result<(), DispatchError>
fn hold( reason: &Self::Reason, who: &AccountId, amount: Self::Balance ) -> Result<(), DispatchError>
reason
is already in place, then this
will increase it.§fn release(
reason: &Self::Reason,
who: &AccountId,
amount: Self::Balance,
precision: Precision
) -> Result<Self::Balance, DispatchError>
fn release( reason: &Self::Reason, who: &AccountId, amount: Self::Balance, precision: Precision ) -> Result<Self::Balance, DispatchError>
amount
held funds in an account. Read more§fn set_on_hold(
reason: &Self::Reason,
who: &AccountId,
amount: Self::Balance
) -> Result<(), DispatchError>
fn set_on_hold( reason: &Self::Reason, who: &AccountId, amount: Self::Balance ) -> Result<(), DispatchError>
who
to bring the balance on hold for reason
to
exactly amount
.§fn release_all(
reason: &Self::Reason,
who: &AccountId,
precision: Precision
) -> Result<Self::Balance, DispatchError>
fn release_all( reason: &Self::Reason, who: &AccountId, precision: Precision ) -> Result<Self::Balance, DispatchError>
§fn burn_held(
reason: &Self::Reason,
who: &AccountId,
amount: Self::Balance,
precision: Precision,
force: Fortitude
) -> Result<Self::Balance, DispatchError>
fn burn_held( reason: &Self::Reason, who: &AccountId, amount: Self::Balance, precision: Precision, force: Fortitude ) -> Result<Self::Balance, DispatchError>
§fn burn_all_held(
reason: &Self::Reason,
who: &AccountId,
precision: Precision,
force: Fortitude
) -> Result<Self::Balance, DispatchError>
fn burn_all_held( reason: &Self::Reason, who: &AccountId, precision: Precision, force: Fortitude ) -> Result<Self::Balance, DispatchError>
§fn transfer_on_hold(
reason: &Self::Reason,
source: &AccountId,
dest: &AccountId,
amount: Self::Balance,
precision: Precision,
mode: Restriction,
force: Fortitude
) -> Result<Self::Balance, DispatchError>
fn transfer_on_hold( reason: &Self::Reason, source: &AccountId, dest: &AccountId, amount: Self::Balance, precision: Precision, mode: Restriction, force: Fortitude ) -> Result<Self::Balance, DispatchError>
§fn transfer_and_hold(
reason: &Self::Reason,
source: &AccountId,
dest: &AccountId,
amount: Self::Balance,
precision: Precision,
expendability: Preservation,
force: Fortitude
) -> Result<Self::Balance, DispatchError>
fn transfer_and_hold( reason: &Self::Reason, source: &AccountId, dest: &AccountId, amount: Self::Balance, precision: Precision, expendability: Preservation, force: Fortitude ) -> Result<Self::Balance, DispatchError>
amount
of free balance from source
to become owned by dest
but on hold
for reason
. Read morefn done_hold(_reason: &Self::Reason, _who: &AccountId, _amount: Self::Balance)
fn done_release( _reason: &Self::Reason, _who: &AccountId, _amount: Self::Balance )
fn done_burn_held( _reason: &Self::Reason, _who: &AccountId, _amount: Self::Balance )
fn done_transfer_on_hold( _reason: &Self::Reason, _source: &AccountId, _dest: &AccountId, _amount: Self::Balance )
fn done_transfer_and_hold( _reason: &Self::Reason, _source: &AccountId, _dest: &AccountId, _transferred: Self::Balance )
§impl<T, I> NamedReservableCurrency<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
<T as Config<I>>::Balance: MaybeSerializeDeserialize + Debug,
impl<T, I> NamedReservableCurrency<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
<T as Config<I>>::Balance: MaybeSerializeDeserialize + Debug,
§fn reserve_named(
id: &<Pallet<T, I> as NamedReservableCurrency<<T as Config>::AccountId>>::ReserveIdentifier,
who: &<T as Config>::AccountId,
value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
) -> Result<(), DispatchError>
fn reserve_named( id: &<Pallet<T, I> as NamedReservableCurrency<<T as Config>::AccountId>>::ReserveIdentifier, who: &<T as Config>::AccountId, value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance ) -> Result<(), DispatchError>
Move value
from the free balance from who
to a named reserve balance.
Is a no-op if value to be reserved is zero.
§fn unreserve_named(
id: &<Pallet<T, I> as NamedReservableCurrency<<T as Config>::AccountId>>::ReserveIdentifier,
who: &<T as Config>::AccountId,
value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
fn unreserve_named( id: &<Pallet<T, I> as NamedReservableCurrency<<T as Config>::AccountId>>::ReserveIdentifier, who: &<T as Config>::AccountId, value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance ) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
Unreserve some funds, returning any amount that was unable to be unreserved.
Is a no-op if the value to be unreserved is zero.
§fn slash_reserved_named(
id: &<Pallet<T, I> as NamedReservableCurrency<<T as Config>::AccountId>>::ReserveIdentifier,
who: &<T as Config>::AccountId,
value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
) -> (<Pallet<T, I> as Currency<<T as Config>::AccountId>>::NegativeImbalance, <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance)
fn slash_reserved_named( id: &<Pallet<T, I> as NamedReservableCurrency<<T as Config>::AccountId>>::ReserveIdentifier, who: &<T as Config>::AccountId, value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance ) -> (<Pallet<T, I> as Currency<<T as Config>::AccountId>>::NegativeImbalance, <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance)
Slash from reserved balance, returning the negative imbalance created, and any amount that was unable to be slashed.
Is a no-op if the value to be slashed is zero.
§fn repatriate_reserved_named(
id: &<Pallet<T, I> as NamedReservableCurrency<<T as Config>::AccountId>>::ReserveIdentifier,
slashed: &<T as Config>::AccountId,
beneficiary: &<T as Config>::AccountId,
value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance,
status: BalanceStatus
) -> Result<<Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance, DispatchError>
fn repatriate_reserved_named( id: &<Pallet<T, I> as NamedReservableCurrency<<T as Config>::AccountId>>::ReserveIdentifier, slashed: &<T as Config>::AccountId, beneficiary: &<T as Config>::AccountId, value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance, status: BalanceStatus ) -> Result<<Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance, DispatchError>
Move the reserved balance of one account into the balance of another, according to status
.
If status
is Reserved
, the balance will be reserved with given id
.
Is a no-op if:
- the value to be moved is zero; or
- the
slashed
id equal tobeneficiary
and thestatus
isReserved
.
§type ReserveIdentifier = <T as Config<I>>::ReserveIdentifier
type ReserveIdentifier = <T as Config<I>>::ReserveIdentifier
§fn reserved_balance_named(
id: &<Pallet<T, I> as NamedReservableCurrency<<T as Config>::AccountId>>::ReserveIdentifier,
who: &<T as Config>::AccountId
) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
fn reserved_balance_named( id: &<Pallet<T, I> as NamedReservableCurrency<<T as Config>::AccountId>>::ReserveIdentifier, who: &<T as Config>::AccountId ) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
§fn ensure_reserved_named(
id: &Self::ReserveIdentifier,
who: &AccountId,
value: Self::Balance
) -> Result<(), DispatchError>
fn ensure_reserved_named( id: &Self::ReserveIdentifier, who: &AccountId, value: Self::Balance ) -> Result<(), DispatchError>
value
. Read more§fn unreserve_all_named(
id: &Self::ReserveIdentifier,
who: &AccountId
) -> Self::Balance
fn unreserve_all_named( id: &Self::ReserveIdentifier, who: &AccountId ) -> Self::Balance
§fn slash_all_reserved_named(
id: &Self::ReserveIdentifier,
who: &AccountId
) -> Self::NegativeImbalance
fn slash_all_reserved_named( id: &Self::ReserveIdentifier, who: &AccountId ) -> Self::NegativeImbalance
§fn repatriate_all_reserved_named(
id: &Self::ReserveIdentifier,
slashed: &AccountId,
beneficiary: &AccountId,
status: BalanceStatus
) -> Result<(), DispatchError>
fn repatriate_all_reserved_named( id: &Self::ReserveIdentifier, slashed: &AccountId, beneficiary: &AccountId, status: BalanceStatus ) -> Result<(), DispatchError>
status
. If status
is Reserved
, the balance will be reserved with given id
. Read more§impl<T, I> OffchainWorker<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> OffchainWorker<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T, I>where
T: Config<I>,
I: 'static,
§fn offchain_worker(
n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number
)
fn offchain_worker( n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number )
§impl<T, I> OnFinalize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> OnFinalize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T, I>where
T: Config<I>,
I: 'static,
§fn on_finalize(
n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number
)
fn on_finalize( n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number )
Hooks::on_finalize
].§impl<T, I> OnGenesis for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> OnGenesis for Pallet<T, I>where
T: Config<I>,
I: 'static,
§fn on_genesis()
fn on_genesis()
§impl<T, I> OnIdle<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> OnIdle<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T, I>where
T: Config<I>,
I: 'static,
§impl<T, I> OnInitialize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> OnInitialize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T, I>where
T: Config<I>,
I: 'static,
§fn on_initialize(
n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number
) -> Weight
fn on_initialize( n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number ) -> Weight
Hooks::on_initialize
].§impl<T, I> OnPoll<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> OnPoll<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T, I>where
T: Config<I>,
I: 'static,
§impl<T, I> OnRuntimeUpgrade for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> OnRuntimeUpgrade for Pallet<T, I>where
T: Config<I>,
I: 'static,
§fn on_runtime_upgrade() -> Weight
fn on_runtime_upgrade() -> Weight
Hooks::on_runtime_upgrade
].§impl<T, I> PalletInfoAccess for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> PalletInfoAccess for Pallet<T, I>where
T: Config<I>,
I: 'static,
§fn module_name() -> &'static str
fn module_name() -> &'static str
§fn crate_version() -> CrateVersion
fn crate_version() -> CrateVersion
§impl<T, I> PalletsInfoAccess for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> PalletsInfoAccess for Pallet<T, I>where
T: Config<I>,
I: 'static,
§impl<T, I> PartialEq for Pallet<T, I>
impl<T, I> PartialEq for Pallet<T, I>
§impl<T, I> ReservableCurrency<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
<T as Config<I>>::Balance: MaybeSerializeDeserialize + Debug,
impl<T, I> ReservableCurrency<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
<T as Config<I>>::Balance: MaybeSerializeDeserialize + Debug,
§fn can_reserve(
who: &<T as Config>::AccountId,
value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
) -> bool
fn can_reserve( who: &<T as Config>::AccountId, value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance ) -> bool
Check if who
can reserve value
from their free balance.
Always true
if value to be reserved is zero.
§fn reserve(
who: &<T as Config>::AccountId,
value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
) -> Result<(), DispatchError>
fn reserve( who: &<T as Config>::AccountId, value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance ) -> Result<(), DispatchError>
Move value
from the free balance from who
to their reserved balance.
Is a no-op if value to be reserved is zero.
§fn unreserve(
who: &<T as Config>::AccountId,
value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
fn unreserve( who: &<T as Config>::AccountId, value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance ) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
Unreserve some funds, returning any amount that was unable to be unreserved.
Is a no-op if the value to be unreserved is zero or the account does not exist.
NOTE: returns amount value which wasn’t successfully unreserved.
§fn slash_reserved(
who: &<T as Config>::AccountId,
value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
) -> (<Pallet<T, I> as Currency<<T as Config>::AccountId>>::NegativeImbalance, <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance)
fn slash_reserved( who: &<T as Config>::AccountId, value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance ) -> (<Pallet<T, I> as Currency<<T as Config>::AccountId>>::NegativeImbalance, <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance)
Slash from reserved balance, returning the negative imbalance created, and any amount that was unable to be slashed.
Is a no-op if the value to be slashed is zero or the account does not exist.
§fn repatriate_reserved(
slashed: &<T as Config>::AccountId,
beneficiary: &<T as Config>::AccountId,
value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance,
status: BalanceStatus
) -> Result<<Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance, DispatchError>
fn repatriate_reserved( slashed: &<T as Config>::AccountId, beneficiary: &<T as Config>::AccountId, value: <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance, status: BalanceStatus ) -> Result<<Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance, DispatchError>
Move the reserved balance of one account into the balance of another, according to status
.
Is a no-op if:
- the value to be moved is zero; or
- the
slashed
id equal tobeneficiary
and thestatus
isReserved
.
This is Polite
and thus will not repatriate any funds which would lead the total balance
to be less than the frozen amount. Returns Ok
with the actual amount of funds moved,
which may be less than value
since the operation is done an a BestEffort
basis.
§fn reserved_balance(
who: &<T as Config>::AccountId
) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
fn reserved_balance( who: &<T as Config>::AccountId ) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance
§impl<T, I> StorageInfoTrait for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> StorageInfoTrait for Pallet<T, I>where
T: Config<I>,
I: 'static,
fn storage_info() -> Vec<StorageInfo>
§impl<T, I> Unbalanced<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> Unbalanced<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
§fn handle_dust(dust: Dust<<T as Config>::AccountId, Pallet<T, I>>)
fn handle_dust(dust: Dust<<T as Config>::AccountId, Pallet<T, I>>)
Dust
] can be
converted into a [Credit
] with the [Balanced
] trait impl.§fn write_balance(
who: &<T as Config>::AccountId,
amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance
) -> Result<Option<<Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance>, DispatchError>
fn write_balance( who: &<T as Config>::AccountId, amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance ) -> Result<Option<<Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance>, DispatchError>
§fn set_total_issuance(
amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance
)
fn set_total_issuance( amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance )
amount
.§fn deactivate(
amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance
)
fn deactivate( amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance )
§fn reactivate(
amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance
)
fn reactivate( amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance )
§fn handle_raw_dust(amount: Self::Balance)
fn handle_raw_dust(amount: Self::Balance)
Unbalanced::handle_dust
]. This is an unbalanced
operation and it must only be used when an account is modified in a raw fashion, outside of
the entire fungibles API. The amount
is capped at [Inspect::minimum_balance()
] - 1`. Read more§fn decrease_balance(
who: &AccountId,
amount: Self::Balance,
precision: Precision,
preservation: Preservation,
force: Fortitude
) -> Result<Self::Balance, DispatchError>
fn decrease_balance( who: &AccountId, amount: Self::Balance, precision: Precision, preservation: Preservation, force: Fortitude ) -> Result<Self::Balance, DispatchError>
§fn increase_balance(
who: &AccountId,
amount: Self::Balance,
precision: Precision
) -> Result<Self::Balance, DispatchError>
fn increase_balance( who: &AccountId, amount: Self::Balance, precision: Precision ) -> Result<Self::Balance, DispatchError>
§impl<T, I> Unbalanced<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> Unbalanced<<T as Config>::AccountId> for Pallet<T, I>where
T: Config<I>,
I: 'static,
§fn set_balance_on_hold(
reason: &<Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Reason,
who: &<T as Config>::AccountId,
amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance
) -> Result<(), DispatchError>
fn set_balance_on_hold( reason: &<Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Reason, who: &<T as Config>::AccountId, amount: <Pallet<T, I> as Inspect<<T as Config>::AccountId>>::Balance ) -> Result<(), DispatchError>
who
to amount
. This is independent of any other
balances on hold or the main (“free”) balance. Read more§fn decrease_balance_on_hold(
reason: &Self::Reason,
who: &AccountId,
amount: Self::Balance,
precision: Precision
) -> Result<Self::Balance, DispatchError>
fn decrease_balance_on_hold( reason: &Self::Reason, who: &AccountId, amount: Self::Balance, precision: Precision ) -> Result<Self::Balance, DispatchError>
§fn increase_balance_on_hold(
reason: &Self::Reason,
who: &AccountId,
amount: Self::Balance,
precision: Precision
) -> Result<Self::Balance, DispatchError>
fn increase_balance_on_hold( reason: &Self::Reason, who: &AccountId, amount: Self::Balance, precision: Precision ) -> Result<Self::Balance, DispatchError>
§impl<T, I> WhitelistedStorageKeys for Pallet<T, I>where
T: Config<I>,
I: 'static,
impl<T, I> WhitelistedStorageKeys for Pallet<T, I>where
T: Config<I>,
I: 'static,
§fn whitelisted_storage_keys() -> Vec<TrackedStorageKey>
fn whitelisted_storage_keys() -> Vec<TrackedStorageKey>
Vec<TrackedStorageKey>
indicating the storage keys that
should be whitelisted during benchmarking. This means that those keys
will be excluded from the benchmarking performance calculation.