Enum Call 

pub enum Call<T: Config> {
    create_collection {},
    define_item {
        collection: CollectionId,
        metadata: Vec<(MetadataKeyOf<T>, MetadataValueOf<T>)>,
    },
    mint {
        collection: CollectionId,
        item: ItemIndex,
        to: T::AccountId,
        metadata: Vec<(MetadataKeyOf<T>, MetadataValueOf<T>)>,
    },
    transfer {
        to: T::AccountId,
    },
    burn {},
    nominate_collection_owner {
        collection: CollectionId,
        pending_owner: Option<T::AccountId>,
    },
    set_collection_metadata {
        collection: CollectionId,
        key: MetadataKeyOf<T>,
        value: Option<MetadataValueOf<T>>,
    },
    set_item_metadata {
        collection: CollectionId,
        item: ItemIndex,
        key: MetadataKeyOf<T>,
        value: Option<MetadataValueOf<T>>,
    },
    claim_collection_ownership {
        collection: CollectionId,
    },
    set_instance_metadata {
        instance: InstanceId,
        key: MetadataKeyOf<T>,
        value: Option<MetadataValueOf<T>>,
    },
    force_burn {
        instance: InstanceId,
    },
    delete_item {
        collection: CollectionId,
        item: ItemIndex,
    },
    delete_collection {
        collection: CollectionId,
    },
    force_transfer {
        instance: InstanceId,
        to: T::AccountId,
    },
    // some variants omitted
}

Contains a variant per dispatchable extrinsic that this pallet has.

Variants

create_collection

Create a collection owned by the signer.

define_item

Define one immutable item and its shared metadata defaults.

The supplied metadata is inherited by every instance minted from this definition. Instance-specific values belong on Self::mint or Self::set_instance_metadata.

Fields

collection: CollectionId

metadata: Vec<(MetadataKeyOf<T>, MetadataValueOf<T>)>

mint

Mint an instance of an immutable item definition into an empty purse key.

The destination gives no consent; any empty key is a valid target. See the module documentation on purse-key occupancy.

metadata contains instance-specific overrides. Item metadata remains the shared default for every instance minted from the definition.

Fields

collection: CollectionId

item: ItemIndex

to: T::AccountId

metadata: Vec<(MetadataKeyOf<T>, MetadataValueOf<T>)>

transfer

Transfer an NFT held by the Origin::Nft purse-key origin.

Fields

to: T::AccountId

burn

Burn an NFT held by the Origin::Nft purse-key origin.

Item-definition supply counts minted-ever instances and is deliberately monotonic. Item metadata belongs to the definition and remains untouched. Instance metadata is removed and its exact deposits are released.

nominate_collection_owner

Nominate an account to claim ownership of a collection.

Only the current owner may nominate or clear a prospective owner. Nomination does not change authority or move deposits.

Fields

collection: CollectionId

pending_owner: Option<T::AccountId>

set_collection_metadata

Set or remove a collection-level metadata default.

Only the collection owner may mutate metadata. None releases an existing entry’s deposit; when the key is absent it is a successful no-op.

Fields

collection: CollectionId

key: MetadataKeyOf<T>

value: Option<MetadataValueOf<T>>

set_item_metadata

Set or remove a metadata default shared by every instance of an item.

This scope overrides the collection default without changing any instance-specific override. Only the collection owner may mutate metadata. None releases an existing entry’s deposit; when the key is absent it is a successful no-op.

Fields

collection: CollectionId

item: ItemIndex

key: MetadataKeyOf<T>

value: Option<MetadataValueOf<T>>

claim_collection_ownership

Claim a collection after nomination by its current owner.

An equivalent aggregate consideration is first created for the claimant and then the previous owner’s ticket is dropped. The operation is atomic: failure to establish the claimant’s consideration leaves ownership and both tickets unchanged.

Fields

collection: CollectionId

set_instance_metadata

Set or remove an instance-specific metadata override.

Only the collection owner may mutate metadata. None releases an existing entry’s deposit; when the key is absent it is a successful no-op.

Fields

instance: InstanceId

key: MetadataKeyOf<T>

value: Option<MetadataValueOf<T>>

force_burn

Force-burn one live instance as its collection owner.

The collection layer intentionally applies no holder-level ACL. When a runtime exposes this call to its contract environment, a contract-owned collection can enforce its own consent and game rules before calling it.

Fields

instance: InstanceId

delete_item

Delete an unused item definition owned by the signer.

Every live instance must be burned and every item metadata entry removed first. Deleted item indices are never reused.

Fields

collection: CollectionId

item: ItemIndex

delete_collection

Delete an empty collection owned by the signer.

Every item definition and collection metadata entry must be removed first. Deleted collection identifiers are never reused.

Fields

collection: CollectionId

force_transfer

Force-transfer one live instance as its collection owner.

The collection layer intentionally applies no holder-level ACL. When a runtime exposes this call to its contract environment, a contract-owned collection can enforce its own consent and game rules before calling it. The move increments the instance state nonce, invalidating prior holder authorizations.

Fields

instance: InstanceId

to: T::AccountId

Implementations

impl<T: Config> Call<T>

pub fn new_call_variant_create_collection() -> Self

Create a call with the variant create_collection.

pub fn new_call_variant_define_item( collection: CollectionId, metadata: Vec<(MetadataKeyOf<T>, MetadataValueOf<T>)>, ) -> Self

Create a call with the variant define_item.

pub fn new_call_variant_mint( collection: CollectionId, item: ItemIndex, to: T::AccountId, metadata: Vec<(MetadataKeyOf<T>, MetadataValueOf<T>)>, ) -> Self

Create a call with the variant mint.

pub fn new_call_variant_transfer(to: T::AccountId) -> Self

Create a call with the variant transfer.

pub fn new_call_variant_burn() -> Self

Create a call with the variant burn.

pub fn new_call_variant_nominate_collection_owner( collection: CollectionId, pending_owner: Option<T::AccountId>, ) -> Self

Create a call with the variant nominate_collection_owner.

pub fn new_call_variant_set_collection_metadata( collection: CollectionId, key: MetadataKeyOf<T>, value: Option<MetadataValueOf<T>>, ) -> Self

Create a call with the variant set_collection_metadata.

pub fn new_call_variant_set_item_metadata( collection: CollectionId, item: ItemIndex, key: MetadataKeyOf<T>, value: Option<MetadataValueOf<T>>, ) -> Self

Create a call with the variant set_item_metadata.

pub fn new_call_variant_claim_collection_ownership( collection: CollectionId, ) -> Self

Create a call with the variant claim_collection_ownership.

pub fn new_call_variant_set_instance_metadata( instance: InstanceId, key: MetadataKeyOf<T>, value: Option<MetadataValueOf<T>>, ) -> Self

Create a call with the variant set_instance_metadata.

pub fn new_call_variant_force_burn(instance: InstanceId) -> Self

Create a call with the variant force_burn.

pub fn new_call_variant_delete_item( collection: CollectionId, item: ItemIndex, ) -> Self

Create a call with the variant delete_item.

pub fn new_call_variant_delete_collection(collection: CollectionId) -> Self

Create a call with the variant delete_collection.

pub fn new_call_variant_force_transfer( instance: InstanceId, to: T::AccountId, ) -> Self

Create a call with the variant force_transfer.

Trait Implementations

impl<T: Config> Authorize for Call<T>

fn authorize( &self, source: TransactionSource, ) -> Option<Result<(ValidTransaction, Weight), TransactionValidityError>>

The authorize function.

fn weight_of_authorize(&self) -> Weight

The weight of the authorization function.

impl<T: Config> CheckIfFeeless for Call<T>

type Origin = <T as Config>::RuntimeOrigin

The Origin type of the runtime.

fn is_feeless(&self, origin: &Self::Origin) -> bool

Checks if the dispatchable satisfies the feeless condition as defined by #[pallet::feeless_if]

impl<T: Config> Clone for Call<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Config> Debug for Call<T>

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

Formats the value using the given formatter.

impl<T: Config> Decode for Call<T>

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<T: Config> Encode for Call<T>

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<T: Config> GetCallIndex for Call<T>

fn get_call_index(&self) -> u8

Return the index of this Call.

fn get_call_indices() -> &'static [u8]

Return all call indices in the same order as [GetCallName].

impl<T: Config> GetCallName for Call<T>

fn get_call_name(&self) -> &'static str

Return the function name of the Call.

fn get_call_names() -> &'static [&'static str]

Return all function names in the same order as [GetCallIndex].

impl<T: Config> GetDispatchInfo for Call<T>

fn get_dispatch_info(&self) -> DispatchInfo

Return a DispatchInfo, containing relevant information of this dispatch.

impl<T: Config> PartialEq for Call<T>

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> TypeInfo for Call<T>

where PhantomData<(T,)>: TypeInfo + 'static, Vec<(MetadataKeyOf<T>, MetadataValueOf<T>)>: TypeInfo + 'static, T::AccountId: TypeInfo + 'static, Option<T::AccountId>: TypeInfo + 'static, MetadataKeyOf<T>: TypeInfo + 'static, Option<MetadataValueOf<T>>: TypeInfo + 'static, T: Config + 'static,

type Identity = Call<T>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T: Config> UnfilteredDispatchable for Call<T>

type RuntimeOrigin = <T as Config>::RuntimeOrigin

The origin type of the runtime, (i.e. frame_system::Config::RuntimeOrigin).

fn dispatch_bypass_filter( self, origin: Self::RuntimeOrigin, ) -> DispatchResultWithPostInfo

Dispatch this call but do not check the filter in origin.

impl<T: Config> DecodeWithMemTracking for Call<T>

where Vec<(MetadataKeyOf<T>, MetadataValueOf<T>)>: DecodeWithMemTracking, T::AccountId: DecodeWithMemTracking, Option<T::AccountId>: DecodeWithMemTracking, MetadataKeyOf<T>: DecodeWithMemTracking, Option<MetadataValueOf<T>>: DecodeWithMemTracking,

impl<T: Config> EncodeLike for Call<T>

impl<T: Config> Eq for Call<T>