Struct orml_tokens::Mapper

pub struct Mapper<AccountId, T, C, B, GetCurrencyId>(/* private fields */);

Trait Implementations

impl<AccountId, T, C, B, GetCurrencyId> Inspect<AccountId> for Mapper<AccountId, T, C, B, GetCurrencyId>

where T: Inspect<AccountId>, C: ConvertBalance<<T as Inspect<AccountId>>::Balance, B, AssetId = <T as Inspect<AccountId>>::AssetId>, B: BalanceT, GetCurrencyId: Get<<T as Inspect<AccountId>>::AssetId>,

type Balance = B

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

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

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

fn reducible_balance( 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 reduction and potentially go below user-level restrictions on the minimum amount of the account.

fn can_deposit( who: &AccountId, amount: Self::Balance, provenance: Provenance ) -> 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 Success if the balance of who may be decreased by amount, otherwise the consequence.

fn active_issuance() -> Self::Balance

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

impl<AccountId, T, C, B, GetCurrencyId> Mutate<AccountId> for Mapper<AccountId, T, C, B, GetCurrencyId>

where T: Mutate<AccountId, Balance = B>, C: ConvertBalance<<T as Inspect<AccountId>>::Balance, B, AssetId = <T as Inspect<AccountId>>::AssetId>, B: BalanceT, GetCurrencyId: Get<<T as Inspect<AccountId>>::AssetId>, AccountId: Eq,

fn mint_into( 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( 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( source: &AccountId, dest: &AccountId, amount: B, preservation: Preservation ) -> Result<B, DispatchError>

Transfer funds from one account into another.

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

Attempt to decrease the asset balance of who by amount.

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

Attempt to increase the asset balance of who by amount.

fn set_balance(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(_who: &AccountId, _amount: Self::Balance)

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

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

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

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

impl<AccountId, T, C, B, GetCurrencyId> Unbalanced<AccountId> for Mapper<AccountId, T, C, B, GetCurrencyId>

where T: Unbalanced<AccountId, Balance = B>, C: ConvertBalance<<T as Inspect<AccountId>>::Balance, B, AssetId = <T as Inspect<AccountId>>::AssetId>, B: BalanceT, GetCurrencyId: Get<<T as Inspect<AccountId>>::AssetId>,

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

Forcefully set the balance of who to amount.

fn set_total_issuance(amount: Self::Balance)

Set the total issuance to amount.

fn handle_raw_dust(amount: Self::Balance)

Create some dust and handle it with Unbalanced::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 Inspect::minimum_balance() - 1`.

fn decrease_balance( 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( who: &AccountId, amount: Self::Balance, precision: Precision ) -> Result<Self::Balance, DispatchError>

Increase the balance of who by amount.

fn deactivate(_: Self::Balance)

Reduce the active issuance by some amount.

fn reactivate(_: Self::Balance)

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