Struct orml_nft::Module

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

Implementations

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

pub fn next_class_id() -> T::ClassId

Next available class ID.

pub fn next_token_id() -> T::TokenId

Next available token ID.

pub fn classes<K: EncodeLike<T::ClassId>>(key: K) -> Option<ClassInfoOf<T>>

Store class info.

Returns None if class info not set or removed.

pub fn tokens<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> Option<TokenInfoOf<T>> where
    KArg1: EncodeLike<T::ClassId>,
    KArg2: EncodeLike<T::TokenId>, 

pub fn tokens_by_owner<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> Option<()> where
    KArg1: EncodeLike<T::AccountId>,
    KArg2: EncodeLike<(T::ClassId, T::TokenId)>, 

impl<T: Trait> Module<T>

pub fn create_class(
    owner: &T::AccountId,
    metadata: CID,
    data: T::ClassData
) -> Result<T::ClassId, DispatchError>

Create NFT(non fungible token) class

pub fn transfer(
    from: &T::AccountId,
    to: &T::AccountId,
    token: (T::ClassId, T::TokenId)
) -> DispatchResult

Transfer NFT(non fungible token) from from account to to account

pub fn mint(
    owner: &T::AccountId,
    class_id: T::ClassId,
    metadata: CID,
    data: T::TokenData
) -> Result<T::TokenId, DispatchError>

Mint NFT(non fungible token) to owner

pub fn burn(
    owner: &T::AccountId,
    token: (T::ClassId, T::TokenId)
) -> DispatchResult

Burn NFT(non fungible token) from owner

pub fn destroy_class(
    owner: &T::AccountId,
    class_id: T::ClassId
) -> DispatchResult

Destroy NFT(non fungible token) class

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 + 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>