Struct orml_currencies::Module

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

Implementations

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 as Trait>::MultiCurrency as MultiCurrency<<T as Trait>::AccountId>>::CurrencyId,
    amount: <<T as Trait>::MultiCurrency as MultiCurrency<<T as Trait>::AccountId>>::Balance
) -> DispatchResult

Transfer some balance to another account under currency_id.

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

• Preconditions:
  • T::MultiCurrency is orml_tokens
  • T::NativeCurrency is pallet_balances
• Complexity: O(1)
• Db reads: 5
• Db writes: 2

---

Base Weight: - non-native currency: 90.23 µs - native currency in worst case: 70 µs

NOTE: Calling this function will bypass origin filters.

pub fn transfer_native_currency(
    origin: T::Origin,
    dest: <T::Lookup as StaticLookup>::Source,
    amount: <<T as Trait>::MultiCurrency as MultiCurrency<<T as Trait>::AccountId>>::Balance
) -> DispatchResult

Transfer some native currency to another account.

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

• Preconditions:
  • T::MultiCurrency is orml_tokens
  • T::NativeCurrency is pallet_balances
• Complexity: O(1)
• Db reads: 2 * Accounts
• Db writes: 2 * Accounts

---

Base Weight: 70 µs

NOTE: Calling this function will bypass origin filters.

pub fn update_balance(
    origin: T::Origin,
    who: <T::Lookup as StaticLookup>::Source,
    currency_id: <<T as Trait>::MultiCurrency as MultiCurrency<<T as Trait>::AccountId>>::CurrencyId,
    amount: <<T as Trait>::MultiCurrency as MultiCurrencyExtended<<T as Trait>::AccountId>>::Amount
) -> DispatchResult

update amount of account who under currency_id.

The dispatch origin of this call must be Root.

• Preconditions:
  • T::MultiCurrency is orml_tokens
  • T::NativeCurrency is pallet_balances
• Complexity: O(1)
• Db reads:
  • non-native currency: 5
• Db writes:
  • non-native currency: 2

---

Base Weight: - non-native currency: 66.24 µs - native currency and killing account: 26.33 µs - native currency and create account: 27.39 µ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 as Trait>::MultiCurrency as MultiCurrency<<T as Trait>::AccountId>>::CurrencyId

The currency identifier.

type Balance = <<T as Trait>::MultiCurrency as MultiCurrency<<T as Trait>::AccountId>>::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 amount from one account to another.

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

Add amount to the balance of who under currency_id and increase total issuance.

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,
    amount: 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

Deduct the balance of who by up to amount.

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

type Amount = <<T as Trait>::MultiCurrency as MultiCurrencyExtended<<T as Trait>::AccountId>>::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

Same result as reserve(who, value) (but without the side-effects) assuming there are no balance changes in the meantime.

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

Deducts up to value from reserved balance of who. This function cannot fail.

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

Moves value from balance to reserved balance.

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

Moves up to value from reserved balance to free balance. This function cannot fail.

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

Moves up to value from reserved balance of account slashed to balance of account beneficiary. beneficiary must exist for this to succeed. If it does not, Err will be returned. Funds will be placed in either the free balance or the reserved balance, depending on the status.

impl<T: Trait + 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 + 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 + 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>