Trait frame_support::traits::tokens::currency::Currency [−][src]
pub trait Currency<AccountId> { type Balance: Balance + MaybeSerializeDeserialize + Debug + MaxEncodedLen; type PositiveImbalance: Imbalance<Self::Balance, Opposite = Self::NegativeImbalance>; type NegativeImbalance: Imbalance<Self::Balance, Opposite = Self::PositiveImbalance>;}Show methods
fn total_balance(who: &AccountId) -> Self::Balance; fn can_slash(who: &AccountId, value: Self::Balance) -> bool; fn total_issuance() -> Self::Balance; fn minimum_balance() -> Self::Balance; fn burn(amount: Self::Balance) -> Self::PositiveImbalance; fn issue(amount: Self::Balance) -> Self::NegativeImbalance; fn free_balance(who: &AccountId) -> Self::Balance; fn ensure_can_withdraw(
who: &AccountId,
_amount: Self::Balance,
reasons: WithdrawReasons,
new_balance: Self::Balance
) -> DispatchResult; fn transfer(
source: &AccountId,
dest: &AccountId,
value: Self::Balance,
existence_requirement: ExistenceRequirement
) -> DispatchResult; fn slash(
who: &AccountId,
value: Self::Balance
) -> (Self::NegativeImbalance, Self::Balance); fn deposit_into_existing(
who: &AccountId,
value: Self::Balance
) -> Result<Self::PositiveImbalance, DispatchError>; fn deposit_creating(
who: &AccountId,
value: Self::Balance
) -> Self::PositiveImbalance; fn withdraw(
who: &AccountId,
value: Self::Balance,
reasons: WithdrawReasons,
liveness: ExistenceRequirement
) -> Result<Self::NegativeImbalance, DispatchError>; fn make_free_balance_be(
who: &AccountId,
balance: Self::Balance
) -> SignedImbalance<Self::Balance, Self::PositiveImbalance>; fn pair(
amount: Self::Balance
) -> (Self::PositiveImbalance, Self::NegativeImbalance) { ... } fn resolve_into_existing(
who: &AccountId,
value: Self::NegativeImbalance
) -> Result<(), Self::NegativeImbalance> { ... } fn resolve_creating(who: &AccountId, value: Self::NegativeImbalance) { ... } fn settle(
who: &AccountId,
value: Self::PositiveImbalance,
reasons: WithdrawReasons,
liveness: ExistenceRequirement
) -> Result<(), Self::PositiveImbalance> { ... }
Expand description
Abstraction over a fungible assets system.
Associated Types
type Balance: Balance + MaybeSerializeDeserialize + Debug + MaxEncodedLen
type Balance: Balance + MaybeSerializeDeserialize + Debug + MaxEncodedLen
The balance of an account.
type PositiveImbalance: Imbalance<Self::Balance, Opposite = Self::NegativeImbalance>
type PositiveImbalance: Imbalance<Self::Balance, Opposite = Self::NegativeImbalance>
The opaque token type for an imbalance. This is returned by unbalanced operations and must be dealt with. It may be dropped but cannot be cloned.
type NegativeImbalance: Imbalance<Self::Balance, Opposite = Self::PositiveImbalance>
type NegativeImbalance: Imbalance<Self::Balance, Opposite = Self::PositiveImbalance>
The opaque token type for an imbalance. This is returned by unbalanced operations and must be dealt with. It may be dropped but cannot be cloned.
Required methods
fn total_balance(who: &AccountId) -> Self::Balance
fn total_balance(who: &AccountId) -> Self::Balance
The combined balance of who
.
Same result as 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() -> Self::Balance
fn total_issuance() -> Self::Balance
The total amount of issuance in the system.
fn minimum_balance() -> Self::Balance
fn minimum_balance() -> Self::Balance
The minimum balance any single account may have. This is equivalent to the Balances
module’s
ExistentialDeposit
.
fn burn(amount: Self::Balance) -> Self::PositiveImbalance
fn burn(amount: Self::Balance) -> Self::PositiveImbalance
Reduce the total issuance by amount
and return the according imbalance. The imbalance will
typically be used to reduce an account by the same amount with e.g. settle
.
This is infallible, but doesn’t guarantee that the entire amount
is burnt, for example
in the case of underflow.
fn issue(amount: Self::Balance) -> Self::NegativeImbalance
fn issue(amount: Self::Balance) -> Self::NegativeImbalance
Increase the total issuance by 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
.
This is infallible, but doesn’t guarantee that the entire amount
is issued, for example
in the case of overflow.
fn free_balance(who: &AccountId) -> Self::Balance
fn free_balance(who: &AccountId) -> Self::Balance
The ‘free’ balance of a given account.
This is the only balance that matters in terms of most operations on tokens. It alone
is used to determine the balance when in the contract execution environment. When this
balance falls below the value of ExistentialDeposit
, then the ‘current account’ is
deleted: specifically FreeBalance
.
system::AccountNonce
is also deleted if ReservedBalance
is also zero (it also gets
collapsed to zero if it ever becomes less than ExistentialDeposit
.
fn ensure_can_withdraw(
who: &AccountId,
_amount: Self::Balance,
reasons: WithdrawReasons,
new_balance: Self::Balance
) -> DispatchResult
fn ensure_can_withdraw(
who: &AccountId,
_amount: Self::Balance,
reasons: WithdrawReasons,
new_balance: Self::Balance
) -> DispatchResult
Returns 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
.
Err(...)
with the reason why not otherwise.
fn transfer(
source: &AccountId,
dest: &AccountId,
value: Self::Balance,
existence_requirement: ExistenceRequirement
) -> DispatchResult
fn transfer(
source: &AccountId,
dest: &AccountId,
value: Self::Balance,
existence_requirement: ExistenceRequirement
) -> DispatchResult
Transfer some liquid free balance to another staker.
This is a very high-level function. It will ensure all appropriate fees are paid and no imbalance in the system remains.
Deducts up to value
from the combined balance of who
, preferring to deduct from the
free balance. This function cannot fail.
The resulting imbalance is the first item of the tuple returned.
As much funds up to value
will be deducted as possible. If this is less than value
,
then a non-zero second item will be returned.
fn deposit_into_existing(
who: &AccountId,
value: Self::Balance
) -> Result<Self::PositiveImbalance, DispatchError>
fn deposit_into_existing(
who: &AccountId,
value: Self::Balance
) -> Result<Self::PositiveImbalance, DispatchError>
Mints value
to the free balance of who
.
If who
doesn’t exist, nothing is done and an Err returned.
fn deposit_creating(
who: &AccountId,
value: Self::Balance
) -> Self::PositiveImbalance
fn deposit_creating(
who: &AccountId,
value: Self::Balance
) -> Self::PositiveImbalance
Adds up to value
to the free balance of who
. If who
doesn’t exist, it is created.
Infallible.
fn withdraw(
who: &AccountId,
value: Self::Balance,
reasons: WithdrawReasons,
liveness: ExistenceRequirement
) -> Result<Self::NegativeImbalance, DispatchError>
fn withdraw(
who: &AccountId,
value: Self::Balance,
reasons: WithdrawReasons,
liveness: ExistenceRequirement
) -> Result<Self::NegativeImbalance, DispatchError>
Removes some free balance from who
account for reason
if possible. If liveness
is
KeepAlive
, then no less than ExistentialDeposit
must be left remaining.
This checks any locks, vesting, and liquidity requirements. If the removal is not possible,
then it returns Err
.
If the operation is successful, this will return Ok
with a NegativeImbalance
whose value
is value
.
fn make_free_balance_be(
who: &AccountId,
balance: Self::Balance
) -> SignedImbalance<Self::Balance, Self::PositiveImbalance>
fn make_free_balance_be(
who: &AccountId,
balance: Self::Balance
) -> SignedImbalance<Self::Balance, Self::PositiveImbalance>
Ensure an account’s free balance equals some value; this will create the account if needed.
Returns a signed imbalance and status to indicate if the account was successfully updated or update has led to killing of the account.
Provided methods
fn pair(
amount: Self::Balance
) -> (Self::PositiveImbalance, Self::NegativeImbalance)
fn pair(
amount: Self::Balance
) -> (Self::PositiveImbalance, Self::NegativeImbalance)
Produce a pair of imbalances that cancel each other out exactly.
This is just the same as burning and issuing the same amount and has no effect on the total issuance.
fn resolve_into_existing(
who: &AccountId,
value: Self::NegativeImbalance
) -> Result<(), Self::NegativeImbalance>
fn resolve_into_existing(
who: &AccountId,
value: Self::NegativeImbalance
) -> Result<(), Self::NegativeImbalance>
Similar to deposit_creating, only accepts a NegativeImbalance
and returns nothing on
success.
fn resolve_creating(who: &AccountId, value: Self::NegativeImbalance)
fn resolve_creating(who: &AccountId, value: Self::NegativeImbalance)
Similar to deposit_creating, only accepts a 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>
Similar to withdraw, only accepts a PositiveImbalance
and returns nothing on success.