Struct pallet_uniques::pallet::Pallet

pub struct Pallet<T, I = ()>(_);

The pallet implementing the on-chain logic.

Implementations

impl<T: Config<I>, I: 'static> Pallet<T, I>

pub fn do_transfer(
    collection: T::CollectionId,
    item: T::ItemId,
    dest: T::AccountId,
    with_details: impl FnOnce(&CollectionDetails<<T as SystemConfig>::AccountId, <<T as Config<I>>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance>, &mut ItemDetails<<T as SystemConfig>::AccountId, <<T as Config<I>>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance>) -> DispatchResult
) -> DispatchResult

pub fn do_create_collection(
    collection: T::CollectionId,
    owner: T::AccountId,
    admin: T::AccountId,
    deposit: <<T as Config<I>>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance,
    free_holding: bool,
    event: Event<T, I>
) -> DispatchResult

pub fn do_destroy_collection(
    collection: T::CollectionId,
    witness: DestroyWitness,
    maybe_check_owner: Option<T::AccountId>
) -> Result<DestroyWitness, DispatchError>

pub fn do_mint(
    collection: T::CollectionId,
    item: T::ItemId,
    owner: T::AccountId,
    with_details: impl FnOnce(&CollectionDetails<<T as SystemConfig>::AccountId, <<T as Config<I>>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance>) -> DispatchResult
) -> DispatchResult

pub fn do_burn(
    collection: T::CollectionId,
    item: T::ItemId,
    with_details: impl FnOnce(&CollectionDetails<<T as SystemConfig>::AccountId, <<T as Config<I>>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance>, &ItemDetails<<T as SystemConfig>::AccountId, <<T as Config<I>>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance>) -> DispatchResult
) -> DispatchResult

pub fn do_set_price(
    collection: T::CollectionId,
    item: T::ItemId,
    sender: T::AccountId,
    price: Option<<<T as Config<I>>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance>,
    whitelisted_buyer: Option<T::AccountId>
) -> DispatchResult

pub fn do_buy_item(
    collection: T::CollectionId,
    item: T::ItemId,
    buyer: T::AccountId,
    bid_price: <<T as Config<I>>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance
) -> DispatchResult

impl<T: Config<I>, I: 'static> Pallet<T, I>

pub fn owner(
    collection: T::CollectionId,
    item: T::ItemId
) -> Option<T::AccountId>

Get the owner of the item, if the item exists.

pub fn collection_owner(collection: T::CollectionId) -> Option<T::AccountId>

Get the owner of the item, if the item exists.

impl<T: Config<I>, I: 'static> Pallet<T, I>

pub fn create(
    origin: OriginFor<T>,
    collection: T::CollectionId,
    admin: <<T as Config>::Lookup as StaticLookup>::Source
) -> DispatchResult

Issue a new collection of non-fungible items from a public origin.

This new collection has no items initially and its owner is the origin.

The origin must be Signed and the sender must have sufficient funds free.

ItemDeposit funds of sender are reserved.

Parameters:

• collection: The identifier of the new collection. This must not be currently in use.
• admin: The admin of this collection. The admin is the initial address of each member of the collection’s admin team.

Emits Created event when successful.

Weight: O(1)

pub fn force_create(
    origin: OriginFor<T>,
    collection: T::CollectionId,
    owner: <<T as Config>::Lookup as StaticLookup>::Source,
    free_holding: bool
) -> DispatchResult

Issue a new collection of non-fungible items from a privileged origin.

This new collection has no items initially.

The origin must conform to ForceOrigin.

Unlike create, no funds are reserved.

• collection: The identifier of the new item. This must not be currently in use.
• owner: The owner of this collection of items. The owner has full superuser permissions over this item, but may later change and configure the permissions using transfer_ownership and set_team.

Emits ForceCreated event when successful.

Weight: O(1)

pub fn destroy(
    origin: OriginFor<T>,
    collection: T::CollectionId,
    witness: DestroyWitness
) -> DispatchResultWithPostInfo

Destroy a collection of fungible items.

The origin must conform to ForceOrigin or must be Signed and the sender must be the owner of the collection.

• collection: The identifier of the collection to be destroyed.
• witness: Information on the items minted in the collection. This must be correct.

Emits Destroyed event when successful.

Weight: O(n + m) where:

• n = witness.items
• m = witness.item_metadatas
• a = witness.attributes

pub fn mint(
    origin: OriginFor<T>,
    collection: T::CollectionId,
    item: T::ItemId,
    owner: <<T as Config>::Lookup as StaticLookup>::Source
) -> DispatchResult

Mint an item of a particular collection.

The origin must be Signed and the sender must be the Issuer of the collection.

• collection: The collection of the item to be minted.
• item: The item value of the item to be minted.
• beneficiary: The initial owner of the minted item.

Emits Issued event when successful.

Weight: O(1)

pub fn burn(
    origin: OriginFor<T>,
    collection: T::CollectionId,
    item: T::ItemId,
    check_owner: Option<<<T as Config>::Lookup as StaticLookup>::Source>
) -> DispatchResult

Destroy a single item.

Origin must be Signed and the sender should be the Admin of the collection.

• collection: The collection of the item to be burned.
• item: The item of the item to be burned.
• check_owner: If Some then the operation will fail with WrongOwner unless the item is owned by this value.

Emits Burned with the actual amount burned.

Weight: O(1) Modes: check_owner.is_some().

pub fn transfer(
    origin: OriginFor<T>,
    collection: T::CollectionId,
    item: T::ItemId,
    dest: <<T as Config>::Lookup as StaticLookup>::Source
) -> DispatchResult

Move an item from the sender account to another.

This resets the approved account of the item.

Origin must be Signed and the signing account must be either:

• the Admin of the collection;
• the Owner of the item;
• the approved delegate for the item (in this case, the approval is reset).

Arguments:

• collection: The collection of the item to be transferred.
• item: The item of the item to be transferred.
• dest: The account to receive ownership of the item.

Emits Transferred.

Weight: O(1)

pub fn redeposit(
    origin: OriginFor<T>,
    collection: T::CollectionId,
    items: Vec<T::ItemId>
) -> DispatchResult

Reevaluate the deposits on some items.

Origin must be Signed and the sender should be the Owner of the collection.

• collection: The collection to be frozen.
• items: The items of the collection whose deposits will be reevaluated.

NOTE: This exists as a best-effort function. Any items which are unknown or in the case that the owner account does not have reservable funds to pay for a deposit increase are ignored. Generally the owner isn’t going to call this on items whose existing deposit is less than the refreshed deposit as it would only cost them, so it’s of little consequence.

It will still return an error in the case that the collection is unknown of the signer is not permitted to call it.

Weight: O(items.len())

pub fn freeze(
    origin: OriginFor<T>,
    collection: T::CollectionId,
    item: T::ItemId
) -> DispatchResult

Disallow further unprivileged transfer of an item.

Origin must be Signed and the sender should be the Freezer of the collection.

• collection: The collection of the item to be frozen.
• item: The item of the item to be frozen.

Emits Frozen.

Weight: O(1)

pub fn thaw(
    origin: OriginFor<T>,
    collection: T::CollectionId,
    item: T::ItemId
) -> DispatchResult

Re-allow unprivileged transfer of an item.

Origin must be Signed and the sender should be the Freezer of the collection.

• collection: The collection of the item to be thawed.
• item: The item of the item to be thawed.

Emits Thawed.

Weight: O(1)

pub fn freeze_collection(
    origin: OriginFor<T>,
    collection: T::CollectionId
) -> DispatchResult

Disallow further unprivileged transfers for a whole collection.

Origin must be Signed and the sender should be the Freezer of the collection.

• collection: The collection to be frozen.

Emits CollectionFrozen.

Weight: O(1)

pub fn thaw_collection(
    origin: OriginFor<T>,
    collection: T::CollectionId
) -> DispatchResult

Re-allow unprivileged transfers for a whole collection.

Origin must be Signed and the sender should be the Admin of the collection.

• collection: The collection to be thawed.

Emits CollectionThawed.

Weight: O(1)

pub fn transfer_ownership(
    origin: OriginFor<T>,
    collection: T::CollectionId,
    owner: <<T as Config>::Lookup as StaticLookup>::Source
) -> DispatchResult

Change the Owner of a collection.

Origin must be Signed and the sender should be the Owner of the collection.

• collection: The collection whose owner should be changed.
• owner: The new Owner of this collection. They must have called set_accept_ownership with collection in order for this operation to succeed.

Emits OwnerChanged.

Weight: O(1)

pub fn set_team(
    origin: OriginFor<T>,
    collection: T::CollectionId,
    issuer: <<T as Config>::Lookup as StaticLookup>::Source,
    admin: <<T as Config>::Lookup as StaticLookup>::Source,
    freezer: <<T as Config>::Lookup as StaticLookup>::Source
) -> DispatchResult

Change the Issuer, Admin and Freezer of a collection.

Origin must be Signed and the sender should be the Owner of the collection.

• collection: The collection whose team should be changed.
• issuer: The new Issuer of this collection.
• admin: The new Admin of this collection.
• freezer: The new Freezer of this collection.

Emits TeamChanged.

Weight: O(1)

pub fn approve_transfer(
    origin: OriginFor<T>,
    collection: T::CollectionId,
    item: T::ItemId,
    delegate: <<T as Config>::Lookup as StaticLookup>::Source
) -> DispatchResult

Approve an item to be transferred by a delegated third-party account.

The origin must conform to ForceOrigin or must be Signed and the sender must be either the owner of the item or the admin of the collection.

• collection: The collection of the item to be approved for delegated transfer.
• item: The item of the item to be approved for delegated transfer.
• delegate: The account to delegate permission to transfer the item.

Important NOTE: The approved account gets reset after each transfer.

Emits ApprovedTransfer on success.

Weight: O(1)

pub fn cancel_approval(
    origin: OriginFor<T>,
    collection: T::CollectionId,
    item: T::ItemId,
    maybe_check_delegate: Option<<<T as Config>::Lookup as StaticLookup>::Source>
) -> DispatchResult

Cancel the prior approval for the transfer of an item by a delegate.

Origin must be either:

• the Force origin;
• Signed with the signer being the Admin of the collection;
• Signed with the signer being the Owner of the item;

Arguments:

• collection: The collection of the item of whose approval will be cancelled.
• item: The item of the item of whose approval will be cancelled.
• maybe_check_delegate: If Some will ensure that the given account is the one to which permission of transfer is delegated.

Emits ApprovalCancelled on success.

Weight: O(1)

pub fn force_item_status(
    origin: OriginFor<T>,
    collection: T::CollectionId,
    owner: <<T as Config>::Lookup as StaticLookup>::Source,
    issuer: <<T as Config>::Lookup as StaticLookup>::Source,
    admin: <<T as Config>::Lookup as StaticLookup>::Source,
    freezer: <<T as Config>::Lookup as StaticLookup>::Source,
    free_holding: bool,
    is_frozen: bool
) -> DispatchResult

Alter the attributes of a given item.

Origin must be ForceOrigin.

• collection: The identifier of the item.
• owner: The new Owner of this item.
• issuer: The new Issuer of this item.
• admin: The new Admin of this item.
• freezer: The new Freezer of this item.
• free_holding: Whether a deposit is taken for holding an item of this collection.
• is_frozen: Whether this collection is frozen except for permissioned/admin instructions.

Emits ItemStatusChanged with the identity of the item.

Weight: O(1)

pub fn set_attribute(
    origin: OriginFor<T>,
    collection: T::CollectionId,
    maybe_item: Option<T::ItemId>,
    key: BoundedVec<u8, T::KeyLimit>,
    value: BoundedVec<u8, T::ValueLimit>
) -> DispatchResult

Set an attribute for a collection or item.

Origin must be either ForceOrigin or Signed and the sender should be the Owner of the collection.

If the origin is Signed, then funds of signer are reserved according to the formula: MetadataDepositBase + DepositPerByte * (key.len + value.len) taking into account any already reserved funds.

• collection: The identifier of the collection whose item’s metadata to set.
• maybe_item: The identifier of the item whose metadata to set.
• key: The key of the attribute.
• value: The value to which to set the attribute.

Emits AttributeSet.

Weight: O(1)

pub fn clear_attribute(
    origin: OriginFor<T>,
    collection: T::CollectionId,
    maybe_item: Option<T::ItemId>,
    key: BoundedVec<u8, T::KeyLimit>
) -> DispatchResult

Clear an attribute for a collection or item.

Origin must be either ForceOrigin or Signed and the sender should be the Owner of the collection.

Any deposit is freed for the collection’s owner.

• collection: The identifier of the collection whose item’s metadata to clear.
• maybe_item: The identifier of the item whose metadata to clear.
• key: The key of the attribute.

Emits AttributeCleared.

Weight: O(1)

pub fn set_metadata(
    origin: OriginFor<T>,
    collection: T::CollectionId,
    item: T::ItemId,
    data: BoundedVec<u8, T::StringLimit>,
    is_frozen: bool
) -> DispatchResult

Set the metadata for an item.

Origin must be either ForceOrigin or Signed and the sender should be the Owner of the collection.

If the origin is Signed, then funds of signer are reserved according to the formula: MetadataDepositBase + DepositPerByte * data.len taking into account any already reserved funds.

• collection: The identifier of the collection whose item’s metadata to set.
• item: The identifier of the item whose metadata to set.
• data: The general information of this item. Limited in length by StringLimit.
• is_frozen: Whether the metadata should be frozen against further changes.

Emits MetadataSet.

Weight: O(1)

pub fn clear_metadata(
    origin: OriginFor<T>,
    collection: T::CollectionId,
    item: T::ItemId
) -> DispatchResult

Clear the metadata for an item.

Origin must be either ForceOrigin or Signed and the sender should be the Owner of the item.

Any deposit is freed for the collection’s owner.

• collection: The identifier of the collection whose item’s metadata to clear.
• item: The identifier of the item whose metadata to clear.

Emits MetadataCleared.

Weight: O(1)

pub fn set_collection_metadata(
    origin: OriginFor<T>,
    collection: T::CollectionId,
    data: BoundedVec<u8, T::StringLimit>,
    is_frozen: bool
) -> DispatchResult

Set the metadata for a collection.

Origin must be either ForceOrigin or Signed and the sender should be the Owner of the collection.

If the origin is Signed, then funds of signer are reserved according to the formula: MetadataDepositBase + DepositPerByte * data.len taking into account any already reserved funds.

• collection: The identifier of the item whose metadata to update.
• data: The general information of this item. Limited in length by StringLimit.
• is_frozen: Whether the metadata should be frozen against further changes.

Emits CollectionMetadataSet.

Weight: O(1)

pub fn clear_collection_metadata(
    origin: OriginFor<T>,
    collection: T::CollectionId
) -> DispatchResult

Clear the metadata for a collection.

Origin must be either ForceOrigin or Signed and the sender should be the Owner of the collection.

Any deposit is freed for the collection’s owner.

• collection: The identifier of the collection whose metadata to clear.

Emits CollectionMetadataCleared.

Weight: O(1)

pub fn set_accept_ownership(
    origin: OriginFor<T>,
    maybe_collection: Option<T::CollectionId>
) -> DispatchResult

Set (or reset) the acceptance of ownership for a particular account.

Origin must be Signed and if maybe_collection is Some, then the signer must have a provider reference.

• maybe_collection: The identifier of the collection whose ownership the signer is willing to accept, or if None, an indication that the signer is willing to accept no ownership transferal.

Emits OwnershipAcceptanceChanged.

pub fn set_collection_max_supply(
    origin: OriginFor<T>,
    collection: T::CollectionId,
    max_supply: u32
) -> DispatchResult

Set the maximum amount of items a collection could have.

Origin must be either ForceOrigin or Signed and the sender should be the Owner of the collection.

Note: This function can only succeed once per collection.

• collection: The identifier of the collection to change.
• max_supply: The maximum amount of items a collection could have.

Emits CollectionMaxSupplySet event when successful.

pub fn set_price(
    origin: OriginFor<T>,
    collection: T::CollectionId,
    item: T::ItemId,
    price: Option<<<T as Config<I>>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance>,
    whitelisted_buyer: Option<<<T as Config>::Lookup as StaticLookup>::Source>
) -> DispatchResult

Set (or reset) the price for an item.

Origin must be Signed and must be the owner of the asset item.

• collection: The collection of the item.
• item: The item to set the price for.
• price: The price for the item. Pass None, to reset the price.
• buyer: Restricts the buy operation to a specific account.

Emits ItemPriceSet on success if the price is not None. Emits ItemPriceRemoved on success if the price is None.

pub fn buy_item(
    origin: OriginFor<T>,
    collection: T::CollectionId,
    item: T::ItemId,
    bid_price: <<T as Config<I>>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance
) -> DispatchResult

Allows to buy an item if it’s up for sale.

Origin must be Signed and must not be the owner of the item.

• collection: The collection of the item.
• item: The item the sender wants to buy.
• bid_price: The price the sender is willing to pay.

Emits ItemBought on success.

Trait Implementations

impl<T, I: 'static> Benchmarking for Pallet<T, I>where
    T: Config + Config<I>,

fn benchmarks(extra: bool) -> Vec<BenchmarkMetadata>

Get the benchmarks available for this pallet. Generally there is one benchmark per extrinsic, so these are sometimes just called “extrinsics”.

fn run_benchmark(
    extrinsic: &[u8],
    c: &[(BenchmarkParameter, u32)],
    whitelist: &[TrackedStorageKey],
    verify: bool,
    internal_repeats: u32
) -> Result<Vec<BenchmarkResult>, BenchmarkError>

Run the benchmarks for this pallet.

impl<T: Config<I>, I: 'static> Callable<T> for Pallet<T, I>

type Call = Call<T, I>

impl<T, I> Clone for Pallet<T, I>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Config<I>, I: 'static> Create<<T as Config>::AccountId> for Pallet<T, I>

fn create_collection(
    collection: &Self::CollectionId,
    who: &T::AccountId,
    admin: &T::AccountId
) -> DispatchResult

Create a collection of nonfungible items to be owned by who and managed by admin.

impl<T, I> Debug for Pallet<T, I>

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

Formats the value using the given formatter.

impl<T: Config<I>, I: 'static> Destroy<<T as Config>::AccountId> for Pallet<T, I>

type DestroyWitness = DestroyWitness

The witness data needed to destroy an item.

fn get_destroy_witness(
    collection: &Self::CollectionId
) -> Option<DestroyWitness>

Provide the appropriate witness data needed to destroy an item.

fn destroy(
    collection: Self::CollectionId,
    witness: Self::DestroyWitness,
    maybe_check_owner: Option<T::AccountId>
) -> Result<Self::DestroyWitness, DispatchError>

Destroy an existing fungible item.

impl<T: Config<I>, I: 'static> GetStorageVersion for Pallet<T, I>

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<I>, I: 'static> Hooks<<T as Config>::BlockNumber> for Pallet<T, I>

fn on_finalize(_n: BlockNumber)

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

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

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

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

fn on_runtime_upgrade() -> Weight

Perform a module upgrade.

fn try_state(_n: BlockNumber) -> Result<(), &'static str>

Execute the sanity checks of this pallet, per block.

fn pre_upgrade() -> Result<(), &'static str>

Execute some pre-checks prior to a runtime upgrade.

fn post_upgrade() -> Result<(), &'static str>

Execute some post-checks after a runtime 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<I>, I: 'static> Inspect<<T as Config>::AccountId> for Pallet<T, I>

fn attribute(
    collection: &Self::CollectionId,
    item: &Self::ItemId,
    key: &[u8]
) -> Option<Vec<u8>>

Returns the attribute value of item of collection corresponding to key.

When key is empty, we return the item metadata value.

By default this is None; no attributes are defined.

fn collection_attribute(
    collection: &Self::CollectionId,
    key: &[u8]
) -> Option<Vec<u8>>

Returns the attribute value of item of collection corresponding to key.

When key is empty, we return the item metadata value.

By default this is None; no attributes are defined.

fn can_transfer(collection: &Self::CollectionId, item: &Self::ItemId) -> bool

Returns true if the item of collection may be transferred.

Default implementation is that all items are transferable.

type ItemId = <T as Config<I>>::ItemId

Type for identifying an item.

type CollectionId = <T as Config<I>>::CollectionId

Type for identifying a collection (an identifier for an independent collection of items).

fn owner(
    collection: &Self::CollectionId,
    item: &Self::ItemId
) -> Option<<T as SystemConfig>::AccountId>

Returns the owner of item of collection, or None if the item doesn’t exist (or somehow has no owner).

fn collection_owner(
    collection: &Self::CollectionId
) -> Option<<T as SystemConfig>::AccountId>

Returns the owner of the collection, if there is one. For many NFTs this may not make any sense, so users of this API should not be surprised to find a collection results in None here.

fn typed_attribute<K, V>(
    collection: &Self::CollectionId,
    item: &Self::ItemId,
    key: &K
) -> Option<V>where
    K: Encode,
    V: Decode,

Returns the strongly-typed attribute value of item of collection corresponding to key.

fn typed_collection_attribute<K, V>(
    collection: &Self::CollectionId,
    key: &K
) -> Option<V>where
    K: Encode,
    V: Decode,

Returns the strongly-typed attribute value of collection corresponding to key.

impl<T: Config<I>, I: 'static> InspectEnumerable<<T as Config>::AccountId> for Pallet<T, I>

fn collections() -> Box<dyn Iterator<Item = Self::CollectionId>>

Returns an iterator of the collections in existence.

NOTE: iterating this list invokes a storage read per item.

fn items(
    collection: &Self::CollectionId
) -> Box<dyn Iterator<Item = Self::ItemId>>

Returns an iterator of the items of a collection in existence.

NOTE: iterating this list invokes a storage read per item.

fn owned(
    who: &T::AccountId
) -> Box<dyn Iterator<Item = (Self::CollectionId, Self::ItemId)>>

Returns an iterator of the items of all collections owned by who.

NOTE: iterating this list invokes a storage read per item.

fn owned_in_collection(
    collection: &Self::CollectionId,
    who: &T::AccountId
) -> Box<dyn Iterator<Item = Self::ItemId>>

Returns an iterator of the items of collection owned by who.

NOTE: iterating this list invokes a storage read per item.

impl<T: Config<I>, I: 'static> IntegrityTest for Pallet<T, I>

fn integrity_test()

Run integrity test.

impl<T: Config<I>, I: 'static> Mutate<<T as Config>::AccountId> for Pallet<T, I>

fn mint_into(
    collection: &Self::CollectionId,
    item: &Self::ItemId,
    who: &T::AccountId
) -> DispatchResult

Mint some item of collection to be owned by who.

fn burn(
    collection: &Self::CollectionId,
    item: &Self::ItemId,
    maybe_check_owner: Option<&T::AccountId>
) -> DispatchResult

Burn some item of collection.

fn set_attribute(
    _collection: &Self::CollectionId,
    _item: &Self::ItemId,
    _key: &[u8],
    _value: &[u8]
) -> Result<(), DispatchError>

Set attribute value of item of collection’s key.

fn set_typed_attribute<K, V>(
    collection: &Self::CollectionId,
    item: &Self::ItemId,
    key: &K,
    value: &V
) -> Result<(), DispatchError>where
    K: Encode,
    V: Encode,

Attempt to set the strongly-typed attribute value of item of collection’s key.

fn set_collection_attribute(
    _collection: &Self::CollectionId,
    _key: &[u8],
    _value: &[u8]
) -> Result<(), DispatchError>

Set attribute value of collection’s key.

fn set_typed_collection_attribute<K, V>(
    collection: &Self::CollectionId,
    key: &K,
    value: &V
) -> Result<(), DispatchError>where
    K: Encode,
    V: Encode,

Attempt to set the strongly-typed attribute value of collection’s key.

impl<T: Config<I>, I: 'static> OffchainWorker<<T as Config>::BlockNumber> for Pallet<T, I>

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

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

impl<T: Config<I>, I: 'static> OnFinalize<<T as Config>::BlockNumber> for Pallet<T, I>

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

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

impl<T: Config<I>, I: 'static> OnGenesis for Pallet<T, I>

fn on_genesis()

Something that should happen at genesis.

impl<T: Config<I>, I: 'static> OnIdle<<T as Config>::BlockNumber> for Pallet<T, I>

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<I>, I: 'static> OnInitialize<<T as Config>::BlockNumber> for Pallet<T, I>

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

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

impl<T: Config<I>, I: 'static> OnRuntimeUpgrade for Pallet<T, I>

fn on_runtime_upgrade() -> Weight

Perform a module upgrade.

fn pre_upgrade() -> Result<(), &'static str>

Execute some pre-checks prior to a runtime upgrade.

fn post_upgrade() -> Result<(), &'static str>

Execute some post-checks after a runtime upgrade.

impl<T: Config<I>, I: 'static> PalletInfoAccess for Pallet<T, I>

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<I>, I: 'static> PalletsInfoAccess for Pallet<T, I>

fn count() -> usize

The number of pallets’ information that this type represents.

fn infos() -> Vec<PalletInfoData>

All of the pallets’ information that this type represents.

impl<T, I> PartialEq<Pallet<T, I>> for Pallet<T, I>

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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Config<I>, I: 'static> StorageInfoTrait for Pallet<T, I>

fn storage_info() -> Vec<StorageInfo>

impl<T: Config<I>, I: 'static> Transfer<<T as Config>::AccountId> for Pallet<T, I>

fn transfer(
    collection: &Self::CollectionId,
    item: &Self::ItemId,
    destination: &T::AccountId
) -> DispatchResult

Transfer item of collection into destination account.

impl<T: Config<I>, I: 'static> TryState<<T as Config>::BlockNumber> for Pallet<T, I>

fn try_state(
    n: <T as Config>::BlockNumber,
    _s: TryStateSelect
) -> Result<(), &'static str>

Execute the state checks.

impl<T, I> Eq for Pallet<T, I>