Struct ReservableWithName 

pub struct ReservableWithName<NamedReservable, Id, AccountId>(/* private fields */);

Adapter to allow a NamedReservableCurrency to be passed as regular ReservableCurrency together with an Id.

All “anonymous” operations are then implemented as their named counterparts with the given Id.

Trait Implementations

impl<NamedReservable: NamedReservableCurrency<AccountId>, Id: Get<NamedReservable::ReserveIdentifier>, AccountId> Currency<AccountId> for ReservableWithName<NamedReservable, Id, AccountId>

type Balance = <NamedReservable as Currency<AccountId>>::Balance

The balance of an account.

type PositiveImbalance = <NamedReservable as Currency<AccountId>>::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.

type NegativeImbalance = <NamedReservable as Currency<AccountId>>::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.

fn total_balance(who: &AccountId) -> Self::Balance

The combined balance of who.

fn can_slash(who: &AccountId, value: Self::Balance) -> bool

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

The total amount of issuance in the system.

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

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.

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.

fn pair( amount: Self::Balance, ) -> (Self::PositiveImbalance, Self::NegativeImbalance)

Produce a pair of imbalances that cancel each other out exactly.

fn free_balance(who: &AccountId) -> Self::Balance

The ‘free’ balance of a given account.

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.

fn transfer( source: &AccountId, dest: &AccountId, value: Self::Balance, existence_requirement: ExistenceRequirement, ) -> DispatchResult

Transfer some liquid free balance to another staker.

fn slash( who: &AccountId, value: Self::Balance, ) -> (Self::NegativeImbalance, Self::Balance)

Deducts up to value from the combined balance of who, preferring to deduct from the free balance. This function cannot fail.

fn deposit_into_existing( who: &AccountId, value: Self::Balance, ) -> Result<Self::PositiveImbalance, DispatchError>

Mints value to the free balance of who.

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

fn resolve_creating(who: &AccountId, value: Self::NegativeImbalance)

Similar to deposit_creating, only accepts a NegativeImbalance and returns nothing on success.

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.

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.

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.

fn active_issuance() -> Self::Balance

The total amount of issuance in the system excluding those which are controlled by the system.

fn deactivate(_: Self::Balance)

Reduce the active issuance by some amount.

fn reactivate(_: Self::Balance)

Increase the active issuance by some amount, up to the outstanding amount reduced.

impl<NamedReservable: NamedReservableCurrency<AccountId>, Id: Get<NamedReservable::ReserveIdentifier>, AccountId> ReservableCurrency<AccountId> for ReservableWithName<NamedReservable, Id, AccountId>

fn can_reserve(who: &AccountId, value: Self::Balance) -> bool

Same result as reserve(who, value) (but without the side-effects) assuming there are no balance changes in the meantime.

fn slash_reserved( who: &AccountId, value: Self::Balance, ) -> (Self::NegativeImbalance, Self::Balance)

Deducts up to value from reserved balance of who. This function cannot fail.

fn reserved_balance(who: &AccountId) -> Self::Balance

The amount of the balance of a given account that is externally reserved; this can still get slashed, but gets slashed last of all.

fn reserve(who: &AccountId, value: Self::Balance) -> DispatchResult

Moves value from balance to reserved balance.

fn unreserve(who: &AccountId, value: Self::Balance) -> Self::Balance

Moves up to value from reserved balance to free balance. This function cannot fail.

fn repatriate_reserved( slashed: &AccountId, beneficiary: &AccountId, value: Self::Balance, status: BalanceStatus, ) -> Result<Self::Balance, DispatchError>

Moves up to value from reserved balance of account slashed to balance of account beneficiary. beneficiary must exist for this to succeed. If it does not, Err will be returned. Funds will be placed in either the free balance or the reserved balance, depending on the status.