Struct lagoon_runtime::constants::currency::Adapter

pub struct Adapter<AccountId> { /* private fields */ }

Trait Implementations

impl Inspect<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId> for Adapter<AccountId>

type AssetId = CurrencyId

Means of identifying one asset class from another.

type Balance = u128

Scalar type for representing balance of an account.

fn total_issuance(asset: Self::AssetId) -> Self::Balance

The total amount of issuance in the system.

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

Get the asset balance of who.

fn minimum_balance(asset: Self::AssetId) -> Self::Balance

The minimum balance any single account may have.

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

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

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

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

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

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

fn asset_exists(asset: Self::AssetId) -> bool

Returns true if an asset exists.

fn active_issuance(asset: Self::AssetId) -> Self::Balance

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

impl InspectHold<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId> for Adapter<AccountId>

fn balance_on_hold(asset: Self::AssetId, who: &AccountId) -> Self::Balance

Amount of funds held in hold.

fn can_hold(asset: Self::AssetId, who: &AccountId, amount: Self::Balance) -> bool

Check to see if some amount of asset may be held on the account of who.

impl Mutate<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId> for Adapter<AccountId>

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

Attempt to increase the asset balance of who by amount.

fn burn_from(
    asset: Self::AssetId,
    who: &AccountId,
    amount: Balance
) -> Result<Balance, DispatchError>

Attempt to reduce the asset balance of who by amount.

fn slash(
    asset: Self::AssetId,
    who: &AccountId,
    amount: Self::Balance
) -> Result<Self::Balance, DispatchError>

Attempt to reduce the asset 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(
    asset: Self::AssetId,
    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 MutateHold<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId> for Adapter<AccountId>

fn hold(
    asset: CurrencyId,
    who: &AccountId,
    amount: Self::Balance
) -> DispatchResult

Hold some funds in an account.

fn release(
    asset: CurrencyId,
    who: &AccountId,
    amount: Balance,
    best_effort: bool
) -> Result<Balance, DispatchError>

Release some funds in an account from being on hold.

fn transfer_held(
    asset: CurrencyId,
    source: &AccountId,
    dest: &AccountId,
    amount: Balance,
    best_effort: bool,
    on_hold: bool
) -> Result<Balance, DispatchError>

Transfer held funds into a destination account.

impl Transfer<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId> for Adapter<AccountId>where
    Assets: Transfer<AccountId>,

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

Transfer funds from one account into another.

fn deactivate(_: Self::AssetId, _: Self::Balance)

Reduce the active issuance by some amount.

fn reactivate(_: Self::AssetId, _: Self::Balance)

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