Trait pallet_roles::ReservableCurrency

pub trait ReservableCurrency<AccountId>: Currency<AccountId> {
    fn can_reserve(who: &AccountId, value: Self::Balance) -> bool;
    fn slash_reserved(
        who: &AccountId,
        value: Self::Balance
    ) -> (Self::NegativeImbalance, Self::Balance);
    fn reserved_balance(who: &AccountId) -> Self::Balance;
    fn reserve(
        who: &AccountId,
        value: Self::Balance
    ) -> Result<(), DispatchError>;
    fn unreserve(who: &AccountId, value: Self::Balance) -> Self::Balance;
    fn repatriate_reserved(
        slashed: &AccountId,
        beneficiary: &AccountId,
        value: Self::Balance,
        status: BalanceStatus
    ) -> Result<Self::Balance, DispatchError>;
}

A currency where funds can be reserved from the user.

Required Methods

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.

As much funds up to value will be deducted as possible. If the reserve balance of who is less than value, then a non-zero second item will be returned.

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.

This balance is a ‘reserve’ balance that other subsystems use in order to set aside tokens that are still ‘owned’ by the account holder, but which are suspendable.

When this balance falls below the value of ExistentialDeposit, then this ‘reserve account’ is deleted: specifically, ReservedBalance.

system::AccountNonce is also deleted if FreeBalance is also zero (it also gets collapsed to zero if it ever becomes less than ExistentialDeposit.

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

Moves value from balance to reserved balance.

If the free balance is lower than value, then no funds will be moved and an Err will be returned to notify of this. This is different behavior than unreserve.

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

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

As much funds up to value will be moved as possible. If the reserve balance of who is less than value, then the remaining amount will be returned.

NOTES

• This is different from reserve.
• If the remaining reserved balance is less than ExistentialDeposit, it will invoke on_reserved_too_low and could reap the account.

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.

As much funds up to value will be deducted as possible. If this is less than value, then Ok(non_zero) will be returned.

Implementations on Foreign Types

impl<AccountId> ReservableCurrency<AccountId> for ()

fn can_reserve(_: &AccountId, _: <() as Currency<AccountId>>::Balance) -> bool

fn slash_reserved(
    _: &AccountId,
    _: <() as Currency<AccountId>>::Balance
) -> (<() as Currency<AccountId>>::NegativeImbalance, <() as Currency<AccountId>>::Balance)

fn reserved_balance(_: &AccountId) -> <() as Currency<AccountId>>::Balance

fn reserve(
    _: &AccountId,
    _: <() as Currency<AccountId>>::Balance
) -> Result<(), DispatchError>

fn unreserve(
    _: &AccountId,
    _: <() as Currency<AccountId>>::Balance
) -> <() as Currency<AccountId>>::Balance

fn repatriate_reserved(
    _: &AccountId,
    _: &AccountId,
    _: <() as Currency<AccountId>>::Balance,
    _: BalanceStatus
) -> Result<<() as Currency<AccountId>>::Balance, DispatchError>

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

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>

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

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)

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>

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 to beneficiary and the status is Reserved.

fn reserved_balance(
    who: &<T as Config>::AccountId
) -> <Pallet<T, I> as Currency<<T as Config>::AccountId>>::Balance

Implementors