Struct orml_tokens::module::Pallet

pub struct Pallet<T>(_);

The pallet implementing the on-chain logic.

Implementations

impl<T: Config> Pallet<T>

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

Transfer some liquid free balance to another account.

transfer will set the FreeBalance of the sender and receiver. It will decrease the total issuance of the system by the TransferFee. If the sender’s account is below the existential deposit as a result of the transfer, the account will be reaped.

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

• dest: The recipient of the transfer.
• currency_id: currency type.
• amount: free balance amount to tranfer.

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

Transfer all remaining balance to the given account.

NOTE: This function only attempts to transfer transferable balances. This means that any locked, reserved, or existential deposits (when keep_alive is true), will not be transferred by this function. To ensure that this function results in a killed account, you might need to prepare the account by removing any reference counters, storage deposits, etc…

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

• dest: The recipient of the transfer.
• currency_id: currency type.
• keep_alive: A boolean to determine if the transfer_all operation should send all of the funds the account has, causing the sender account to be killed (false), or transfer everything except at least the existential deposit, which will guarantee to keep the sender account alive (true).

pub fn transfer_keep_alive(
    origin: OriginFor<T>,
    dest: <T::Lookup as StaticLookup>::Source,
    currency_id: T::CurrencyId,
    amount: T::Balance
) -> DispatchResultWithPostInfo

Same as the [transfer] call, but with a check that the transfer will not kill the origin account.

99% of the time you want [transfer] instead.

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

• dest: The recipient of the transfer.
• currency_id: currency type.
• amount: free balance amount to tranfer.

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

Exactly as transfer, except the origin must be root and the source account may be specified.

The dispatch origin for this call must be Root.

• source: The sender of the transfer.
• dest: The recipient of the transfer.
• currency_id: currency type.
• amount: free balance amount to tranfer.

pub fn set_balance(
    origin: OriginFor<T>,
    who: <T::Lookup as StaticLookup>::Source,
    currency_id: T::CurrencyId,
    new_free: T::Balance,
    new_reserved: T::Balance
) -> DispatchResult

Set the balances of a given account.

This will alter FreeBalance and ReservedBalance in storage. it will also decrease the total issuance of the system (TotalIssuance). If the new free or reserved balance is below the existential deposit, it will reap the AccountInfo.

The dispatch origin for this call is root.

impl<T: Config> Pallet<T>

pub fn error_metadata() -> Option<PalletErrorMetadata>

impl<T: Config> Pallet<T>

pub fn total_issuance<KArg>(k: KArg) -> T::Balance where
    KArg: EncodeLike<T::CurrencyId>, 

The total issuance of a token type.

impl<T: Config> Pallet<T>

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

Any liquidity locks of a token type under an account. NOTE: Should only be accessed when setting, changing and freeing a lock.

impl<T: Config> Pallet<T>

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

The balance of a token type under an account.

NOTE: If the total is ever zero, decrease account ref account.

NOTE: This is only used in the case that this module is used to store balances.

Trait Implementations

impl<T: Config> Callable<T> for Pallet<T>

type Call = Call<T>

impl<T> Clone for Pallet<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Pallet<T>

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

Formats the value using the given formatter.

impl<T: Config> GetStorageVersion for Pallet<T>

fn current_storage_version() -> StorageVersion

Returns the current storage version as supported by the pallet.

fn on_chain_storage_version() -> StorageVersion

Returns the on-chain storage version of the pallet as stored in the storage.

impl<T: Config> Hooks<<T as Config>::BlockNumber> for Pallet<T>

fn on_finalize(_n: BlockNumber)

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

fn on_idle(_n: BlockNumber, _remaining_weight: u64) -> u64

This will be run when the block is being finalized (before on_finalize). Implement to have something happen using the remaining weight. Will not fire if the remaining weight is 0. Return the weight used, the hook will subtract it from current weight used and pass the result to the next on_idle hook if it exists.

fn on_initialize(_n: BlockNumber) -> u64

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

fn on_runtime_upgrade() -> u64

Perform a module upgrade.

fn offchain_worker(_n: BlockNumber)

Implementing this function on a module allows you to perform long-running tasks that make (by default) validators generate transactions that feed results of those long-running computations back on chain.

fn integrity_test()

Run integrity test.

impl<T: Config> Inspect<<T as Config>::AccountId> for Pallet<T>

type AssetId = T::CurrencyId

Means of identifying one asset class from another.

type Balance = T::Balance

Scalar type for representing balance of an account.

fn total_issuance(asset_id: Self::AssetId) -> Self::Balance

The total amount of issuance in the system.

fn minimum_balance(asset_id: Self::AssetId) -> Self::Balance

The minimum balance any single account may have.

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

Get the asset balance of who.

fn reducible_balance(
    asset_id: Self::AssetId,
    who: &T::AccountId,
    keep_alive: bool
) -> Self::Balance

Get the maximum amount of asset that who can withdraw/transfer successfully.

fn can_deposit(
    asset_id: Self::AssetId,
    who: &T::AccountId,
    amount: Self::Balance
) -> DepositConsequence

Returns true if the asset balance of who may be increased by amount.

fn can_withdraw(
    asset_id: Self::AssetId,
    who: &T::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<T: Config> InspectHold<<T as Config>::AccountId> for Pallet<T>

fn balance_on_hold(asset_id: Self::AssetId, who: &T::AccountId) -> T::Balance

Amount of funds held in hold.

fn can_hold(
    asset_id: Self::AssetId,
    who: &T::AccountId,
    amount: T::Balance
) -> bool

Check to see if some amount of asset may be held on the account of who.

impl<T: Config> IntegrityTest for Pallet<T>

fn integrity_test()

Run integrity test.

impl<T: Config> MultiCurrency<<T as Config>::AccountId> for Pallet<T>

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.

type CurrencyId = T::CurrencyId

The currency identifier.

type Balance = T::Balance

The balance of an account.

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

Existential deposit of currency_id.

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,
    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.

impl<T: Config> MultiCurrencyExtended<<T as Config>::AccountId> for Pallet<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: Config> MultiLockableCurrency<<T as Config>::AccountId> for Pallet<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
) -> DispatchResult

Create a new balance lock on account who.

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

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
) -> DispatchResult

Remove an existing lock.

impl<T: Config> MultiReservableCurrency<<T as Config>::AccountId> for Pallet<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 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.

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.

impl<T: Config> Mutate<<T as Config>::AccountId> for Pallet<T>

fn mint_into(
    asset_id: Self::AssetId,
    who: &T::AccountId,
    amount: Self::Balance
) -> DispatchResult

Attempt to increase the asset balance of who by amount.

fn burn_from(
    asset_id: Self::AssetId,
    who: &T::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<T: Config> MutateHold<<T as Config>::AccountId> for Pallet<T>

fn hold(
    asset_id: Self::AssetId,
    who: &T::AccountId,
    amount: Self::Balance
) -> DispatchResult

Hold some funds in an account.

fn release(
    asset_id: Self::AssetId,
    who: &T::AccountId,
    amount: Self::Balance,
    best_effort: bool
) -> Result<T::Balance, DispatchError>

Release some funds in an account from being on hold.

fn transfer_held(
    asset_id: Self::AssetId,
    source: &T::AccountId,
    dest: &T::AccountId,
    amount: Self::Balance,
    best_effort: bool,
    on_hold: bool
) -> Result<Self::Balance, DispatchError>

Transfer held funds into a destination account.

impl<T: Config> OffchainWorker<<T as Config>::BlockNumber> for Pallet<T>

fn offchain_worker(n: <T as Config>::BlockNumber)

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

impl<T: Config> OnFinalize<<T as Config>::BlockNumber> for Pallet<T>

fn on_finalize(n: <T as Config>::BlockNumber)

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

impl<T: Config> OnGenesis for Pallet<T>

fn on_genesis()

Something that should happen at genesis.

impl<T: Config> OnIdle<<T as Config>::BlockNumber> for Pallet<T>

fn on_idle(n: <T as Config>::BlockNumber, remaining_weight: Weight) -> Weight

The block is being finalized. Implement to have something happen in case there is leftover weight. Check the passed remaining_weight to make sure it is high enough to allow for your pallet’s extra computation.

impl<T: Config> OnInitialize<<T as Config>::BlockNumber> for Pallet<T>

fn on_initialize(n: <T as Config>::BlockNumber) -> Weight

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

impl<T: Config> OnRuntimeUpgrade for Pallet<T>

fn on_runtime_upgrade() -> Weight

Perform a module upgrade.

impl<T: Config> PalletInfoAccess for Pallet<T>

fn index() -> usize

Index of the pallet as configured in the runtime.

fn name() -> &'static str

Name of the pallet as configured in the runtime.

fn module_name() -> &'static str

Name of the Rust module containing the pallet.

fn crate_version() -> CrateVersion

Version of the crate containing the pallet.

impl<T: Config> PalletsInfoAccess for Pallet<T>

fn count() -> usize

The number of pallets’ information that this type represents.

fn accumulate(acc: &mut Vec<PalletInfoData>)

Extend the given vector by all of the pallets’ information that this type represents.

fn infos() -> Vec<PalletInfoData, Global>

All of the pallets’ information that this type represents.

impl<T> PartialEq<Pallet<T>> for Pallet<T>

fn eq(&self, other: &Self) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: Config> StorageInfoTrait for Pallet<T>

fn storage_info() -> Vec<StorageInfo>

impl<T: Config> Transfer<<T as Config>::AccountId> for Pallet<T>

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

Transfer funds from one account into another.

impl<T: Config> TransferAll<<T as Config>::AccountId> for Pallet<T>

fn transfer_all(source: &T::AccountId, dest: &T::AccountId) -> DispatchResult

impl<T: Config> Unbalanced<<T as Config>::AccountId> for Pallet<T>

fn set_balance(
    asset_id: Self::AssetId,
    who: &T::AccountId,
    amount: Self::Balance
) -> DispatchResult

Set the asset balance of who to amount. If this cannot be done for some reason (e.g. because the account cannot be created or an overflow) then an Err is returned.

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

Set the total issuance of asset to amount.

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

Reduce the asset balance of who by amount. If it cannot be reduced by that amount for some reason, return Err and don’t reduce it at all. If Ok, return the imbalance.

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

Reduce the asset balance of who by the most that is possible, up to amount.

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

Increase the asset balance of who by amount. If it cannot be increased by that amount for some reason, return Err and don’t increase it at all. If Ok, return the imbalance.

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

Increase the asset balance of who by the most that is possible, up to amount.

impl<T> Eq for Pallet<T>