Struct orml_currencies::BasicCurrencyAdapter

pub struct BasicCurrencyAdapter<T, Currency, Amount, Moment>(_);

Adapt other currency traits implementation to BasicCurrency.

Trait Implementations

impl<T, AccountId, Currency, Amount, Moment> BasicCurrency<AccountId> for BasicCurrencyAdapter<T, Currency, Amount, Moment> where
    Currency: PalletCurrency<AccountId>,
    T: Config, 

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

The balance of an account.

fn minimum_balance() -> Self::Balance

Existential deposit.

fn total_issuance() -> Self::Balance

The total amount of issuance.

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

The combined balance of who.

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

The free balance of who.

fn ensure_can_withdraw(who: &AccountId, amount: Self::Balance) -> DispatchResult

A dry-run of withdraw. Returns Ok iff the account is able to make a withdrawal of the given amount.

fn transfer(
    from: &AccountId,
    to: &AccountId,
    amount: Self::Balance
) -> DispatchResult

Transfer some amount from one account to another.

fn deposit(who: &AccountId, amount: Self::Balance) -> DispatchResult

Add amount to the balance of who and increase total issuance.

fn withdraw(who: &AccountId, amount: Self::Balance) -> DispatchResult

Remove amount from the balance of who and reduce total issuance.

fn can_slash(who: &AccountId, amount: 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 slash(who: &AccountId, amount: Self::Balance) -> Self::Balance

Deduct the balance of who by up to amount.

impl<T, AccountId, Currency, Amount, Moment> BasicCurrencyExtended<AccountId> for BasicCurrencyAdapter<T, Currency, Amount, Moment> where
    Amount: Signed + TryInto<<Currency as PalletCurrency<AccountId>>::Balance> + TryFrom<<Currency as PalletCurrency<AccountId>>::Balance> + SimpleArithmetic + Codec + Copy + MaybeSerializeDeserialize + Debug + Default,
    Currency: PalletCurrency<AccountId>,
    T: Config, 

type Amount = Amount

The signed type for balance related operations, typically signed int.

fn update_balance(who: &AccountId, by_amount: Self::Amount) -> DispatchResult

Add or remove abs(by_amount) from the balance of who. If positive by_amount, do add, else do remove.

impl<T, AccountId, Currency, Amount, Moment> BasicLockableCurrency<AccountId> for BasicCurrencyAdapter<T, Currency, Amount, Moment> where
    Currency: PalletLockableCurrency<AccountId>,
    T: Config, 

type Moment = Moment

The quantity used to denote time; usually just a BlockNumber.

fn set_lock(
    lock_id: LockIdentifier,
    who: &AccountId,
    amount: Self::Balance
) -> DispatchResult

Create a new balance lock on account who.

fn extend_lock(
    lock_id: LockIdentifier,
    who: &AccountId,
    amount: Self::Balance
) -> DispatchResult

Changes a balance lock (selected by lock_id) so that it becomes less liquid in all parameters or creates a new one if it does not exist.

fn remove_lock(lock_id: LockIdentifier, who: &AccountId) -> DispatchResult

Remove an existing lock.

impl<T, AccountId, Currency, Amount, Moment> BasicReservableCurrency<AccountId> for BasicCurrencyAdapter<T, Currency, Amount, Moment> where
    Currency: PalletReservableCurrency<AccountId>,
    T: Config, 

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