Struct governance_os_pallet_tokens::NativeCurrencyAdapter

pub struct NativeCurrencyAdapter<Pallet, GetCurrencyId>(_);

This struct is useful to implement the Currency trait for any given currency inside the system. It basically takes an interface to the tokens pallet and a CurrencyId to expose them under the Currency trait.

Trait Implementations

impl<Pallet, GetCurrencyId> Currency<<Pallet as Config>::AccountId> for NativeCurrencyAdapter<Pallet, GetCurrencyId> where
    Pallet: Config,
    GetCurrencyId: Get<Pallet::CurrencyId>, 

type Balance = Pallet::Balance

The balance of an account.

type PositiveImbalance = PositiveImbalance<Pallet, GetCurrencyId>

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 = NegativeImbalance<Pallet, GetCurrencyId>

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: &Pallet::AccountId) -> Self::Balance

The combined balance of who.

fn can_slash(who: &Pallet::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 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 free_balance(who: &Pallet::AccountId) -> Self::Balance

The ‘free’ balance of a given account.

fn ensure_can_withdraw(
    who: &Pallet::AccountId,
    amount: Self::Balance,
    _: WithdrawReasons,
    _: 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: &Pallet::AccountId,
    dest: &Pallet::AccountId,
    amount: Self::Balance,
    _: ExistenceRequirement
) -> DispatchResult

Transfer some liquid free balance to another staker.

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

Mints value to the free balance of who.

fn deposit_creating(
    who: &Pallet::AccountId,
    amount: Self::Balance
) -> Self::PositiveImbalance

Adds up to value to the free balance of who. If who doesn’t exist, it is created.

fn withdraw(
    who: &Pallet::AccountId,
    value: Self::Balance,
    _: WithdrawReasons,
    _: 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 make_free_balance_be(
    who: &Pallet::AccountId,
    value: Self::Balance
) -> SignedImbalance<Self::Balance, Self::PositiveImbalance>

Ensure an account’s free balance equals some value; this will create the account if needed.

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

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

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

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

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

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

impl<Pallet, GetCurrencyId> LockableCurrency<<Pallet as Config>::AccountId> for NativeCurrencyAdapter<Pallet, GetCurrencyId> where
    Pallet: Config,
    GetCurrencyId: Get<Pallet::CurrencyId>, 

type Moment = Pallet::BlockNumber

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

type MaxLocks = ()

The maximum number of locks a user should have on their account.

fn set_lock(
    id: LockIdentifier,
    who: &Pallet::AccountId,
    amount: Self::Balance,
    _reasons: WithdrawReasons
)

Create a new balance lock on account who.

fn extend_lock(
    id: LockIdentifier,
    who: &Pallet::AccountId,
    amount: Self::Balance,
    _reasons: WithdrawReasons
)

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

fn remove_lock(id: LockIdentifier, who: &Pallet::AccountId)

Remove an existing lock.

impl<Pallet, GetCurrencyId> ReservableCurrency<<Pallet as Config>::AccountId> for NativeCurrencyAdapter<Pallet, GetCurrencyId> where
    Pallet: Config,
    GetCurrencyId: Get<Pallet::CurrencyId>, 

fn can_reserve(who: &Pallet::AccountId, amount: 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: &Pallet::AccountId,
    amount: Self::Balance
) -> (Self::NegativeImbalance, Self::Balance)

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

fn reserved_balance(who: &Pallet::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: &Pallet::AccountId, amount: Self::Balance) -> DispatchResult

Moves value from balance to reserved balance.

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

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

fn repatriate_reserved(
    slashed: &Pallet::AccountId,
    beneficiary: &Pallet::AccountId,
    amount: 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.