Struct pallet_commodities::Module

pub struct Module<T: Trait<I>, I: Instance = DefaultInstance>(_);

Implementations

impl<T: Trait<I> + 'static, I: Instance> Module<T, I>

pub fn total() -> u128

The total number of this type of commodity that exists (minted - burned).

pub fn burned() -> u128

The total number of this type of commodity that has been burned (may overflow).

pub fn total_for_account<K: EncodeLike<T::AccountId>>(key: K) -> u64

The total number of this type of commodity owned by an account.

pub fn commodities_for_account<K: EncodeLike<T::AccountId>>(
    key: K
) -> Vec<Commodity<T, I>>

A mapping from an account to a list of all of the commodities of this type that are owned by it.

pub fn account_for_commodity<K: EncodeLike<CommodityId<T>>>(
    key: K
) -> T::AccountId

A mapping from a commodity ID to the account that owns it.

impl<T: Trait<I>, I: Instance> Module<T, I>

Can also be called using Call.

pub fn mint(
    origin: T::Origin,
    owner_account: T::AccountId,
    commodity_info: T::CommodityInfo
) -> DispatchResult

Create a new commodity from the provided commodity info and identify the specified account as its owner. The ID of the new commodity will be equal to the hash of the info that defines it, as calculated by the runtime system's hashing algorithm.

The dispatch origin for this call must be the commodity admin.

This function will throw an error if it is called with commodity info that describes an existing (duplicate) commodity, if the maximum number of this type of commodity already exists or if the specified owner already owns the maximum number of this type of commodity.

• owner_account: Receiver of the commodity.
• commodity_info: The information that defines the commodity.

NOTE: Calling this function will bypass origin filters.

pub fn burn(origin: T::Origin, commodity_id: CommodityId<T>) -> DispatchResult

Destroy the specified commodity.

The dispatch origin for this call must be the commodity owner.

• commodity_id: The hash (calculated by the runtime system's hashing algorithm) of the info that defines the commodity to destroy.

NOTE: Calling this function will bypass origin filters.

pub fn transfer(
    origin: T::Origin,
    dest_account: T::AccountId,
    commodity_id: CommodityId<T>
) -> DispatchResult

Transfer a commodity to a new owner.

The dispatch origin for this call must be the commodity owner.

This function will throw an error if the new owner already owns the maximum number of this type of commodity.

• dest_account: Receiver of the commodity.
• commodity_id: The hash (calculated by the runtime system's hashing algorithm) of the info that defines the commodity to destroy.

NOTE: Calling this function will bypass origin filters.

Trait Implementations

impl<T: Trait<I>, I: Instance> Callable<T> for Module<T, I>

type Call = Call<T, I>

impl<T: Clone + Trait<I>, I: Clone + Instance> Clone for Module<T, I>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy + Trait<I>, I: Copy + Instance> Copy for Module<T, I>

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

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

Formats the value using the given formatter.

impl<T: Eq + Trait<I>, I: Eq + Instance> Eq for Module<T, I>

impl<T: Trait<I>, I: Instance> IntegrityTest for Module<T, I>

fn integrity_test()

Run integrity test.

impl<T: Trait<I>, I: Instance> ModuleErrorMetadata for Module<T, I>

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

impl<T: Trait + Trait<I>, I: Instance> OffchainWorker<<T as Trait>::BlockNumber> for Module<T, I>

fn offchain_worker(_n: BlockNumber)

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

impl<T: Trait + Trait<I>, I: Instance> OnFinalize<<T as Trait>::BlockNumber> for Module<T, I>

fn on_finalize(_n: BlockNumber)

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

impl<T: Trait + Trait<I>, I: Instance> OnInitialize<<T as Trait>::BlockNumber> for Module<T, I>

fn on_initialize(_n: BlockNumber) -> u64

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

impl<T: Trait<I>, I: Instance> OnRuntimeUpgrade for Module<T, I>

fn on_runtime_upgrade() -> u64

Perform a module upgrade.

impl<T: PartialEq + Trait<I>, I: PartialEq + Instance> PartialEq<Module<T, I>> for Module<T, I>

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

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

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

This method tests for !=.

impl<T: Trait<I>, I: Instance> StructuralEq for Module<T, I>

impl<T: Trait<I>, I: Instance> StructuralPartialEq for Module<T, I>

impl<T: Trait<I>, I: Instance> UniqueAssets<<T as Trait>::AccountId> for Module<T, I>

type AssetId = CommodityId<T>

The type used to identify unique assets.

type AssetInfo = T::CommodityInfo

The attributes that distinguish unique assets.

type AssetLimit = T::CommodityLimit

The maximum number of this type of asset that may exist (minted - burned).

type UserAssetLimit = T::UserCommodityLimit

The maximum number of this type of asset that any single account may own.

fn total() -> u128

The total number of this type of asset that exists (minted - burned).

fn burned() -> u128

The total number of this type of asset that has been burned (may overflow).

fn total_for_account(account: &T::AccountId) -> u64

The total number of this type of asset owned by an account.

fn assets_for_account(account: &T::AccountId) -> Vec<Commodity<T, I>>

The set of unique assets owned by an account.

fn owner_of(commodity_id: &CommodityId<T>) -> T::AccountId

The ID of the account that owns an asset.

fn mint(
    owner_account: &T::AccountId,
    commodity_info: <T as Trait<I>>::CommodityInfo
) -> Result<CommodityId<T>, DispatchError>

Use the provided asset info to create a new unique asset for the specified user. This method must return an error in the following cases:

fn burn(commodity_id: &CommodityId<T>) -> DispatchResult

Destroy an asset. This method must return an error in the following case:

fn transfer(
    dest_account: &T::AccountId,
    commodity_id: &CommodityId<T>
) -> DispatchResult

Transfer ownership of an asset to another account. This method must return an error in the following cases: