Struct pallet_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 Currency<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 + MaxEncodedLen,
    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.

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

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

Scalar type for representing balance of an 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.

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

Get the balance of who.

fn reducible_balance(who: &AccountId, keep_alive: bool) -> Self::Balance

Get the maximum amount that who can withdraw/transfer successfully.

fn can_deposit(
    who: &AccountId,
    amount: Self::Balance,
    mint: bool
) -> DepositConsequence

Returns true if the balance of who may be increased by amount.

fn can_withdraw(
    who: &AccountId,
    amount: Self::Balance
) -> WithdrawConsequence<Self::Balance>

Returns Failed if the balance of who may not be decreased by amount, otherwise the consequence.

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

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

Increase the balance of 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
) -> Result<Self::Balance, DispatchError>

Decrease the balance of 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 slash(
    who: &AccountId,
    amount: Self::Balance
) -> Result<Self::Balance, DispatchError>

Attempt to reduce the balance of who by as much as possible up to amount, and possibly slightly more due to minimum_balance requirements. If no decrease is possible then an Err is returned and nothing is changed. If successful, the amount of tokens reduced is returned.

fn teleport(
    source: &AccountId,
    dest: &AccountId,
    amount: Self::Balance
) -> Result<Self::Balance, DispatchError>

Transfer funds from one account into another. The default implementation uses mint_into and burn_from and may generate unwanted events.

impl<T, AccountId, Currency, Amount, Moment, ReserveIdentifier> NamedBasicReservableCurrency<AccountId, ReserveIdentifier> for BasicCurrencyAdapter<T, Currency, Amount, Moment>where
    Currency: PalletNamedReservableCurrency<AccountId, ReserveIdentifier = ReserveIdentifier>,
    T: Config,

fn slash_reserved_named(
    id: &ReserveIdentifier,
    who: &AccountId,
    value: Self::Balance
) -> Self::Balance

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

fn reserved_balance_named(
    id: &ReserveIdentifier,
    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_named(
    id: &ReserveIdentifier,
    who: &AccountId,
    value: Self::Balance
) -> DispatchResult

Moves value from balance to reserved balance.

fn unreserve_named(
    id: &ReserveIdentifier,
    who: &AccountId,
    value: Self::Balance
) -> Self::Balance

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

fn repatriate_reserved_named(
    id: &ReserveIdentifier,
    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.

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

Ensure the reserved balance is equal to value.

fn unreserve_all_named(id: &ReserveIdentifier, who: &AccountId) -> Self::Balance

Unreserve all the named reserved balances, returning unreserved amount.

fn slash_all_reserved_named(
    id: &ReserveIdentifier,
    who: &AccountId
) -> Self::Balance

Slash all the reserved balance, returning the negative imbalance created.

fn repatriate_all_reserved_named(
    id: &ReserveIdentifier,
    slashed: &AccountId,
    beneficiary: &AccountId,
    status: BalanceStatus
) -> Result<(), DispatchError>

Move all the named 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.

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

fn transfer(
    source: &AccountId,
    dest: &AccountId,
    amount: Self::Balance,
    keep_alive: bool
) -> Result<Self::Balance, DispatchError>

Transfer funds from one account into another.