Struct governance_os_pallet_tokens::Module

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

Implementations

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

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

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

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

impl<T: Config> Module<T>

Can also be called using Call.

pub fn create(
    origin: T::Origin,
    currency_id: T::CurrencyId,
    transferable: bool
) -> DispatchResult

Creates a new currency with 0 units, to issue units to people one would have to call issue. This will register the caller of this dispatchable as the owner of the currency so they can issue or burn units. This will produce an error if currency_id is already used by another currency. Use transferable to determine if the created asset can be transferred between accounts. If not, the only way to move it would be to either be root or burn then mint the tokens again.

NOTE: by default, everybody can create new currencies, if it is not wanted you can use the bylaws pallet to restrict access to this dispatchable.

NOTE: Calling this function will bypass origin filters.

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

Issue some units of the currency identified by currency_id and credit them to dest. Can only be called by the owner of the currency.

NOTE: Calling this function will bypass origin filters.

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

Destroy some units of the currency identified by currency_id from from. Can only be called by the owner of the currency.

NOTE: Calling this function will bypass origin filters.

pub fn update_details(
    origin: T::Origin,
    currency_id: T::CurrencyId,
    details: CurrencyDetails<T::AccountId>
) -> DispatchResult

Update details about the currency identified by currency_id. For instance, this can be used to change the owner of the currency. Can only be called by the owner.

NOTE: this will remove ownership / management access from the caller for the given currency if a new owner is specified. However, if other accounts have been granted management access to the same currency (for instance through a root action) this will not change it.

NOTE: Calling this function will bypass origin filters.

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

Transfer amount units of the currency identified by currency_id from the origin’s account to the balance of dest.

NOTE: Calling this function will bypass origin filters.

Trait Implementations

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

type Call = Call<T>

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Config> Currencies<<T as Config>::AccountId> for Module<T>

type CurrencyId = T::CurrencyId

The type used to identify currencies

type Balance = T::Balance

The balance of an account.

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

The total amount of issuance in the system.

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

Remove amount tokens from who balance. If there are not enough tokens it will error.

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

Increase the balance of who by amount.

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

The ‘free’ balance of a given account.

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

The total balance of a given account. This may include non free funds.

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

Returns Ok if the account is able to make a withdrawal of the given amount. Basically, it’s just a dry-run of withdraw.

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

Transfer some liquid free balance to another account.

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

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

Formats the value using the given formatter.

impl<T: Config> GetPalletVersion for Module<T>

fn current_version() -> PalletVersion

Returns the current version of the pallet.

fn storage_version() -> Option<PalletVersion>

Returns the version of the pallet that is stored in storage.

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

pub fn integrity_test()

Run integrity test.

impl<T: Config> LockableCurrencies<<T as Config>::AccountId> for Module<T>

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

Return the total amount of coins locked for the given account.

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

Create a new lock on the balance of who. You can lock more coins than the total balance of a user.

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

Extend an existing lock for who and currency_id. If the lock already exists it will take the maximum value between amount and the existing one.

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

Remove an existing lock.

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

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

impl<T: Config + Config> OffchainWorker<<T as Config>::BlockNumber> for Module<T>

pub fn offchain_worker(_n: BlockNumber)

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

impl<T: Config + Config> OnFinalize<<T as Config>::BlockNumber> for Module<T>

pub fn on_finalize(_n: BlockNumber)

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

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

fn on_genesis()

Something that should happen at genesis.

impl<T: Config + Config> OnInitialize<<T as Config>::BlockNumber> for Module<T>

pub fn on_initialize(_n: BlockNumber) -> u64

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

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

fn on_runtime_upgrade() -> Weight

Perform a module upgrade.

impl<T: PartialEq + Config> 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: Config> ReservableCurrencies<<T as Config>::AccountId> for Module<T>

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

Moves value from balance to reserved balance.

fn unreserve(
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    amount: 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: Copy + Config> Copy for Module<T>

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

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

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