Struct orml_tokens::Module

pub struct Module<T: Trait>(_);

Implementations

impl<T: Trait + 'static> Module<T>

pub fn total_issuance<K: EncodeLike<T::CurrencyId>>(key: K) -> T::Balance

The total issuance of a token type.

pub fn locks<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> Vec<BalanceLock<T::Balance>> where
    KArg1: EncodeLike<T::AccountId>,
    KArg2: EncodeLike<T::CurrencyId>, 

pub fn accounts<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> AccountData<T::Balance> where
    KArg1: EncodeLike<T::AccountId>,
    KArg2: EncodeLike<T::CurrencyId>, 

impl<T: Trait> Module<T>

Can also be called using Call.

pub fn transfer(
    origin: T::Origin,
    dest: <T::Lookup as StaticLookup>::Source,
    currency_id: T::CurrencyId,
    amount: T::Balance
) -> DispatchResult

Transfer some balance to another account.

The dispatch origin for this call must be Signed by the transactor.

• Complexity: O(1)
• Db reads: 4
• Db writes: 2

---

Base Weight: 84.08 µs

NOTE: Calling this function will bypass origin filters.

pub fn transfer_all(
    origin: T::Origin,
    dest: <T::Lookup as StaticLookup>::Source,
    currency_id: T::CurrencyId
) -> DispatchResult

Transfer all remaining balance to the given account.

The dispatch origin for this call must be Signed by the transactor.

• Complexity: O(1)
• Db reads: 4
• Db writes: 2

---

Base Weight: 87.71 µs

NOTE: Calling this function will bypass origin filters.

Trait Implementations

impl<T: Trait> Callable<T> for Module<T>

type Call = Call<T>

impl<T: Clone + Trait> Clone for Module<T>

fn clone(&self) -> Module<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Copy + Trait> Copy for Module<T>

impl<T: Trait> Debug for Module<T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Eq + Trait> Eq for Module<T>

impl<T: Trait> IntegrityTest for Module<T>

fn integrity_test()

Run integrity test.

impl<T: Trait> ModuleErrorMetadata for Module<T>

fn metadata() -> &'static [ErrorMetadata]

impl<T: Trait> MultiCurrency<<T as Trait>::AccountId> for Module<T>

type CurrencyId = T::CurrencyId

The currency identifier.

type Balance = T::Balance

The balance of an account.

fn total_issuance(currency_id: Self::CurrencyId) -> Self::Balance

The total amount of issuance of currency_id.

fn total_balance(
    currency_id: Self::CurrencyId,
    who: &T::AccountId
) -> Self::Balance

fn free_balance(
    currency_id: Self::CurrencyId,
    who: &T::AccountId
) -> Self::Balance

fn ensure_can_withdraw(
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    amount: Self::Balance
) -> DispatchResult

A dry-run of withdraw. Returns Ok iff the account is able to make a withdrawal of the given amount.

fn transfer(
    currency_id: Self::CurrencyId,
    from: &T::AccountId,
    to: &T::AccountId,
    amount: Self::Balance
) -> DispatchResult

Transfer some free balance from from to to. Is a no-op if value to be transferred is zero or the from is the same as to.

fn deposit(
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    amount: Self::Balance
) -> DispatchResult

Deposit some amount into the free balance of account who.

Is a no-op if the amount to be deposited is zero.

fn withdraw(
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    amount: Self::Balance
) -> DispatchResult

Remove amount from the balance of who under currency_id and reduce total issuance.

fn can_slash(
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    value: Self::Balance
) -> bool

Same result as slash(currency_id, 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 slash(
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    amount: Self::Balance
) -> Self::Balance

Is a no-op if value to be slashed is zero.

NOTE: slash() prefers free balance, but assumes that reserve balance can be drawn from in extreme circumstances. can_slash() should be used prior to slash() to avoid having to draw from reserved funds, however we err on the side of punishment if things are inconsistent or can_slash wasn't used appropriately.

impl<T: Trait> MultiCurrencyExtended<<T as Trait>::AccountId> for Module<T>

type Amount = T::Amount

The type for balance related operations, typically signed int.

fn update_balance(
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    by_amount: Self::Amount
) -> DispatchResult

Add or remove abs(by_amount) from the balance of who under currency_id. If positive by_amount, do add, else do remove.

impl<T: Trait> MultiLockableCurrency<<T as Trait>::AccountId> for Module<T>

type Moment = T::BlockNumber

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

fn set_lock(
    lock_id: LockIdentifier,
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    amount: Self::Balance
)

Create a new balance lock on account who.

fn extend_lock(
    lock_id: LockIdentifier,
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    amount: Self::Balance
)

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

fn remove_lock(
    lock_id: LockIdentifier,
    currency_id: Self::CurrencyId,
    who: &T::AccountId
)

Remove an existing lock.

impl<T: Trait> MultiReservableCurrency<<T as Trait>::AccountId> for Module<T>

fn can_reserve(
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    value: Self::Balance
) -> bool

Check if who can reserve value from their free balance.

Always true if value to be reserved is zero.

fn slash_reserved(
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    value: Self::Balance
) -> Self::Balance

Slash from reserved balance, returning any amount that was unable to be slashed.

Is a no-op if the value to be slashed is zero.

fn reserved_balance(
    currency_id: Self::CurrencyId,
    who: &T::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(
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    value: Self::Balance
) -> DispatchResult

Move value from the free balance from who to their reserved balance.

Is a no-op if value to be reserved is zero.

fn unreserve(
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    value: Self::Balance
) -> Self::Balance

Unreserve some funds, returning any amount that was unable to be unreserved.

Is a no-op if the value to be unreserved is zero.

fn repatriate_reserved(
    currency_id: Self::CurrencyId,
    slashed: &T::AccountId,
    beneficiary: &T::AccountId,
    value: Self::Balance,
    status: BalanceStatus
) -> Result<Self::Balance, DispatchError>

Move the reserved balance of one account into the balance of another, according to status.

Is a no-op if:

• the value to be moved is zero; or
• the slashed id equal to beneficiary and the status is Reserved.

impl<T: Trait> OffchainWorker<<T as Trait>::BlockNumber> for Module<T>

fn offchain_worker(_n: BlockNumber)

This function is being called after every block import (when fully synced).

impl<T: Trait> OnFinalize<<T as Trait>::BlockNumber> for Module<T>

fn on_finalize(_n: BlockNumber)

The block is being finalized. Implement to have something happen.

impl<T: Trait> OnInitialize<<T as Trait>::BlockNumber> for Module<T>

fn on_initialize(_n: BlockNumber) -> u64

The block is being initialized. Implement to have something happen.

impl<T: Trait> OnRuntimeUpgrade for Module<T>

fn on_runtime_upgrade() -> u64

Perform a module upgrade.

impl<T: PartialEq + Trait> PartialEq<Module<T>> for Module<T>

fn eq(&self, other: &Module<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Module<T>) -> bool

This method tests for !=.

impl<T: Trait> StructuralEq for Module<T>

impl<T: Trait> StructuralPartialEq for Module<T>