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 balance of who which does not include funds which are exclusively allocated to subsystems of the chain (“on hold” or “reserved”).

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

Get the total amount of funds whose ultimate beneficial ownership can be determined as who.

fn reducible_balance( asset: Self::AssetId, who: &AccountId, preservation: Preservation, fortitude: Fortitude ) -> Self::Balance

Get the maximum amount that who can withdraw/transfer successfully based on whether the account should be kept alive (preservation) or whether we are willing to force the transfer and potentially go below user-level restrictions on the minimum amount of the account.

fn can_deposit( asset: Self::AssetId, who: &AccountId, amount: Self::Balance, provenance: Provenance ) -> 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<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 ) -> Result<Self::Balance, DispatchError>

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( asset: Self::AssetId, dest: &AccountId, amount: Self::Balance, precision: Precision, fortitude: Fortitude ) -> 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 transfer( asset: Self::AssetId, source: &AccountId, dest: &AccountId, amount: Self::Balance, preservation: Preservation ) -> Result<Self::Balance, DispatchError>

Transfer funds from one account into another.

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

Attempt to decrease the asset balance of who by amount.

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

Attempt to increase the asset balance of who by amount.

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

Simple infallible function to force an account to have a particular balance, good for use in tests and benchmarks but not recommended for production code owing to the lack of error reporting.

fn done_mint_into( _asset: Self::AssetId, _who: &AccountId, _amount: Self::Balance )

fn done_burn_from( _asset: Self::AssetId, _who: &AccountId, _amount: Self::Balance )

fn done_shelve(_asset: Self::AssetId, _who: &AccountId, _amount: Self::Balance)

fn done_restore(_asset: Self::AssetId, _who: &AccountId, _amount: Self::Balance)

fn done_transfer( _asset: Self::AssetId, _source: &AccountId, _dest: &AccountId, _amount: Self::Balance )

impl<AccountId, TestKey, A, B> Unbalanced<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 handle_dust(_dust: Dust<AccountId, Self>)

Do something with the dust which has been destroyed from the system. Dust can be converted into a Credit with the Balanced trait impl.

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

Forcefully set the balance of who to amount.

fn set_total_issuance(asset: Self::AssetId, amount: Self::Balance)

Set the total issuance to amount.

fn handle_raw_dust(asset: Self::AssetId, amount: Self::Balance)

Create some dust and handle it with Self::handle_dust. This is an unbalanced operation and it must only be used when an account is modified in a raw fashion, outside of the entire fungibles API. The amount is capped at Self::minimum_balance() - 1.

fn decrease_balance( asset: Self::AssetId, who: &AccountId, amount: Self::Balance, precision: Precision, preservation: Preservation, force: Fortitude ) -> Result<Self::Balance, DispatchError>

Reduce the balance of who by amount.

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

Increase the balance of who by amount.

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

Reduce the active issuance by some amount.

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

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