Struct orml_tokens::Combiner

pub struct Combiner<AccountId, TestKey, A, B>(_);

Trait Implementations

impl<AccountId, TestKey, A, B> Inspect<AccountId> for Combiner<AccountId, TestKey, A, B>where
    TestKey: Contains<<B as Inspect<AccountId>>::AssetId>,
    A: Inspect<AccountId, Balance = <B as Inspect<AccountId>>::Balance>,
    B: Inspect<AccountId>,

type AssetId = <B as Inspect<AccountId>>::AssetId

Means of identifying one asset class from another.

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

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 minimum_balance(asset: Self::AssetId) -> Self::Balance

The minimum balance any single account may have.

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

Get the asset balance of who.

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.

impl<AccountId, TestKey, A, B> Mutate<AccountId> for Combiner<AccountId, TestKey, A, B>where
    TestKey: Contains<<B as Inspect<AccountId>>::AssetId>,
    A: Mutate<AccountId, Balance = <B as Inspect<AccountId>>::Balance>,
    B: Mutate<AccountId>,

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

Attempt to increase the asset balance of who by amount.

fn burn_from(
    asset: Self::AssetId,
    dest: &AccountId,
    amount: Self::Balance
) -> Result<Self::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<AccountId, TestKey, A, B> Transfer<AccountId> for Combiner<AccountId, TestKey, A, B>where
    TestKey: Contains<<B as Inspect<AccountId>>::AssetId>,
    A: Transfer<AccountId, Balance = <B as Inspect<AccountId>>::Balance>,
    B: Transfer<AccountId>,

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

Transfer funds from one account into another.