difftreelog
doc: fix PR
in: master
1 file changed
pallets/common/src/lib.rsdiffbeforeafterboth1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617//! # Common pallet18//!19//! The Common pallet provides an interface for common collection operations for different collection types20//! (see [CommonCollectionOperations]), as well as a generic dispatcher for these, see [dispatch] module.21//! It also provides this functionality to EVM, see [erc] and [eth] modules.22//!23//! ## Overview24//! 25//! The Common pallet provides functionality for handling collections.26//!27//! The Common pallet provides functions for:28//!29//! - Setting and approving collection sponsor.30//! - Get\set\delete allow list.31//! - Get\set\delete collection properties.32//! - Get\set\delete collection property permissions.33//! - Get\set\delete token property permissions.34//! - Get\set\delete collection administrators.35//! - Checking access permissions.36//!37//! ### Terminology38//! **Collection sponsor** - For the collection, you can set a sponsor, at whose expense it will39//! be possible to mint tokens.40//!41//! **Allow list** - List of users who have the right to minting tokens.42//!43//! **Collection properties** - Collection properties are simply key-value stores where various44//! metadata can be placed.45//!46//! **Permissions on token properties** - For each property in the token can be set permission47//! to change, see [PropertyPermission].48//!49//! **Collection administrator** - For a collection, you can set administrators who have the right50//! to most actions on the collection.5152#![warn(missing_docs)]53#![cfg_attr(not(feature = "std"), no_std)]54extern crate alloc;5556use core::ops::{Deref, DerefMut};57use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};58use sp_std::vec::Vec;59use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};60use evm_coder::ToLog;61use frame_support::{62 dispatch::{DispatchErrorWithPostInfo, DispatchResultWithPostInfo, Weight, PostDispatchInfo},63 ensure,64 traits::{Imbalance, Get, Currency, WithdrawReasons, ExistenceRequirement},65 weights::Pays,66 transactional,67};68use pallet_evm::GasWeightMapping;69use up_data_structs::{70 COLLECTION_NUMBER_LIMIT,71 Collection,72 RpcCollection,73 CollectionId,74 CreateItemData,75 MAX_TOKEN_PREFIX_LENGTH,76 COLLECTION_ADMINS_LIMIT,77 TokenId,78 TokenChild,79 CollectionStats,80 MAX_TOKEN_OWNERSHIP,81 CollectionMode,82 NFT_SPONSOR_TRANSFER_TIMEOUT,83 FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,84 REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,85 MAX_SPONSOR_TIMEOUT,86 CUSTOM_DATA_LIMIT,87 CollectionLimits,88 CreateCollectionData,89 SponsorshipState,90 CreateItemExData,91 SponsoringRateLimit,92 budget::Budget,93 PhantomType,94 Property,95 Properties,96 PropertiesPermissionMap,97 PropertyKey,98 PropertyValue,99 PropertyPermission,100 PropertiesError,101 PropertyKeyPermission,102 TokenData,103 TrySetProperty,104 PropertyScope,105 // RMRK106 RmrkCollectionInfo,107 RmrkInstanceInfo,108 RmrkResourceInfo,109 RmrkPropertyInfo,110 RmrkBaseInfo,111 RmrkPartType,112 RmrkBoundedTheme,113 RmrkNftChild,114 CollectionPermissions,115 SchemaVersion,116};117118pub use pallet::*;119use sp_core::H160;120use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};121#[cfg(feature = "runtime-benchmarks")]122pub mod benchmarking;123pub mod dispatch;124pub mod erc;125pub mod eth;126pub mod weights;127128/// Weight info.129pub type SelfWeightOf<T> = <T as Config>::WeightInfo;130131/// Collection handle contains information about collection data and id.132/// Also provides functionality to count consumed gas.133///134/// CollectionHandle is used as a generic wrapper for collections of all types.135/// It allows to perform common operations and queries on any collection type,136/// both completely general for all, as well as their respective implementations of [`CommonCollectionOperations`].137#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]138pub struct CollectionHandle<T: Config> {139 /// Collection id140 pub id: CollectionId,141 collection: Collection<T::AccountId>,142 /// Substrate recorder for counting consumed gas143 pub recorder: SubstrateRecorder<T>,144}145146impl<T: Config> WithRecorder<T> for CollectionHandle<T> {147 fn recorder(&self) -> &SubstrateRecorder<T> {148 &self.recorder149 }150 fn into_recorder(self) -> SubstrateRecorder<T> {151 self.recorder152 }153}154155impl<T: Config> CollectionHandle<T> {156 /// Same as [CollectionHandle::new] but with an explicit gas limit.157 pub fn new_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {158 <CollectionById<T>>::get(id).map(|collection| Self {159 id,160 collection,161 recorder: SubstrateRecorder::new(gas_limit),162 })163 }164165 /// Same as [CollectionHandle::new] but with an existed [`SubstrateRecorder`].166 pub fn new_with_recorder(id: CollectionId, recorder: SubstrateRecorder<T>) -> Option<Self> {167 <CollectionById<T>>::get(id).map(|collection| Self {168 id,169 collection,170 recorder,171 })172 }173174 /// Retrives collection data from storage and creates collection handle with default parameters.175 /// If collection not found return `None`176 pub fn new(id: CollectionId) -> Option<Self> {177 Self::new_with_gas_limit(id, u64::MAX)178 }179180 /// Same as [`CollectionHandle::new`] but if collection not found [`Error::CollectionNotFound`] returned.181 pub fn try_get(id: CollectionId) -> Result<Self, DispatchError> {182 Ok(Self::new(id).ok_or(<Error<T>>::CollectionNotFound)?)183 }184185 /// Consume gas for reading.186 pub fn consume_store_reads(&self, reads: u64) -> evm_coder::execution::Result<()> {187 self.recorder188 .consume_gas(T::GasWeightMapping::weight_to_gas(189 <T as frame_system::Config>::DbWeight::get()190 .read191 .saturating_mul(reads),192 ))193 }194195 /// Consume gas for writing.196 pub fn consume_store_writes(&self, writes: u64) -> evm_coder::execution::Result<()> {197 self.recorder198 .consume_gas(T::GasWeightMapping::weight_to_gas(199 <T as frame_system::Config>::DbWeight::get()200 .write201 .saturating_mul(writes),202 ))203 }204205 /// Save collection to storage.206 pub fn save(self) -> DispatchResult {207 <CollectionById<T>>::insert(self.id, self.collection);208 Ok(())209 }210211 /// Set collection sponsor.212 ///213 /// Unique collections allows sponsoring for certain actions.214 /// This method allows you to set the sponsor of the collection.215 /// In order for sponsorship to become active, it must be confirmed through [`Self::confirm_sponsorship`].216 pub fn set_sponsor(&mut self, sponsor: T::AccountId) -> DispatchResult {217 self.collection.sponsorship = SponsorshipState::Unconfirmed(sponsor);218 Ok(())219 }220221 /// Confirm sponsorship222 ///223 /// In order for the sponsorship to become active, the user set as the sponsor must confirm their participation.224 /// Before confirming sponsorship, the user must be specified as the sponsor of the collection via [`Self::set_sponsor`].225 pub fn confirm_sponsorship(&mut self, sender: &T::AccountId) -> Result<bool, DispatchError> {226 if self.collection.sponsorship.pending_sponsor() != Some(sender) {227 return Ok(false);228 }229230 self.collection.sponsorship = SponsorshipState::Confirmed(sender.clone());231 Ok(true)232 }233234 /// Checks that the collection was created with, and must be operated upon through **Unique API**.235 /// Now check only the `external_collection` flag and if it's **true**, then return [`Error::CollectionIsExternal`] error.236 pub fn check_is_internal(&self) -> DispatchResult {237 if self.external_collection {238 return Err(<Error<T>>::CollectionIsExternal)?;239 }240241 Ok(())242 }243244 /// Checks that the collection was created with, and must be operated upon through an **assimilated API**.245 /// Now check only the `external_collection` flag and if it's **false**, then return [`Error::CollectionIsInternal`] error.246 pub fn check_is_external(&self) -> DispatchResult {247 if !self.external_collection {248 return Err(<Error<T>>::CollectionIsInternal)?;249 }250251 Ok(())252 }253}254255impl<T: Config> Deref for CollectionHandle<T> {256 type Target = Collection<T::AccountId>;257258 fn deref(&self) -> &Self::Target {259 &self.collection260 }261}262263impl<T: Config> DerefMut for CollectionHandle<T> {264 fn deref_mut(&mut self) -> &mut Self::Target {265 &mut self.collection266 }267}268269impl<T: Config> CollectionHandle<T> {270 /// Checks if the `user` is the owner of the collection.271 pub fn check_is_owner(&self, user: &T::CrossAccountId) -> DispatchResult {272 ensure!(*user.as_sub() == self.owner, <Error<T>>::NoPermission);273 Ok(())274 }275276 /// Returns **true** if the `user` is the owner or administrator of the collection.277 pub fn is_owner_or_admin(&self, user: &T::CrossAccountId) -> bool {278 *user.as_sub() == self.owner || <IsAdmin<T>>::get((self.id, user))279 }280281 /// Checks if the `user` is the owner or administrator of the collection.282 pub fn check_is_owner_or_admin(&self, user: &T::CrossAccountId) -> DispatchResult {283 ensure!(self.is_owner_or_admin(user), <Error<T>>::NoPermission);284 Ok(())285 }286287 /// Return **true** if `user` was not allowed to have tokens, and he can ignore such restrictions.288 pub fn ignores_allowance(&self, user: &T::CrossAccountId) -> bool {289 self.limits.owner_can_transfer() && self.is_owner_or_admin(user)290 }291292 /// Return **true** if `user` does not have enough token parts, and he can ignore such restrictions.293 pub fn ignores_owned_amount(&self, user: &T::CrossAccountId) -> bool {294 self.limits.owner_can_transfer() && self.is_owner_or_admin(user)295 }296297 /// Checks if the user is in the allow list. If not [Error::AddressNotInAllowlist] returns.298 pub fn check_allowlist(&self, user: &T::CrossAccountId) -> DispatchResult {299 ensure!(300 <Allowlist<T>>::get((self.id, user)),301 <Error<T>>::AddressNotInAllowlist302 );303 Ok(())304 }305}306307#[frame_support::pallet]308pub mod pallet {309 use super::*;310 use pallet_evm::account;311 use dispatch::CollectionDispatch;312 use frame_support::{Blake2_128Concat, pallet_prelude::*, storage::Key, traits::StorageVersion};313 use frame_system::pallet_prelude::*;314 use frame_support::traits::Currency;315 use up_data_structs::{TokenId, mapping::TokenAddressMapping};316 use scale_info::TypeInfo;317 use weights::WeightInfo;318319 #[pallet::config]320 pub trait Config:321 frame_system::Config322 + pallet_evm_coder_substrate::Config323 + pallet_evm::Config324 + TypeInfo325 + account::Config326 {327 /// Weight information for functions of this pallet.328 type WeightInfo: WeightInfo;329330 /// Events compatible with [`frame_system::Config::Event`].331 type Event: IsType<<Self as frame_system::Config>::Event> + From<Event<Self>>;332333 /// Handler of accounts and payment.334 type Currency: Currency<Self::AccountId>;335336 /// Set price to create a collection.337 #[pallet::constant]338 type CollectionCreationPrice: Get<339 <<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,340 >;341342 /// Dispatcher of operations on collections.343 type CollectionDispatch: CollectionDispatch<Self>;344345 /// Account which holds the chain's treasury.346 type TreasuryAccountId: Get<Self::AccountId>;347348 /// Address under which the CollectionHelper contract would be available.349 type ContractAddress: Get<H160>;350351 /// Mapper for token addresses to Ethereum addresses.352 type EvmTokenAddressMapping: TokenAddressMapping<H160>;353354 /// Mapper for token addresses to [`CrossAccountId`].355 type CrossTokenAddressMapping: TokenAddressMapping<Self::CrossAccountId>;356 }357358 const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);359360 #[pallet::pallet]361 #[pallet::storage_version(STORAGE_VERSION)]362 #[pallet::generate_store(pub(super) trait Store)]363 pub struct Pallet<T>(_);364365 #[pallet::extra_constants]366 impl<T: Config> Pallet<T> {367 /// Maximum admins per collection.368 pub fn collection_admins_limit() -> u32 {369 COLLECTION_ADMINS_LIMIT370 }371 }372373 #[pallet::event]374 #[pallet::generate_deposit(pub fn deposit_event)]375 pub enum Event<T: Config> {376 /// New collection was created377 CollectionCreated(378 /// Globally unique identifier of newly created collection.379 CollectionId,380 /// [`CollectionMode`] converted into _u8_.381 u8,382 /// Collection owner.383 T::AccountId,384 ),385386 /// New collection was destroyed387 CollectionDestroyed(388 /// Globally unique identifier of collection.389 CollectionId,390 ),391392 /// New item was created.393 ItemCreated(394 /// Id of the collection where item was created.395 CollectionId,396 /// Id of an item. Unique within the collection.397 TokenId,398 /// Owner of newly created item399 T::CrossAccountId,400 /// Always 1 for NFT401 u128,402 ),403404 /// Collection item was burned.405 ItemDestroyed(406 /// Id of the collection where item was destroyed.407 CollectionId,408 /// Identifier of burned NFT.409 TokenId,410 /// Which user has destroyed its tokens.411 T::CrossAccountId,412 /// Amount of token pieces destroed. Always 1 for NFT.413 u128,414 ),415416 /// Item was transferred417 Transfer(418 /// Id of collection to which item is belong.419 CollectionId,420 /// Id of an item.421 TokenId,422 /// Original owner of item.423 T::CrossAccountId,424 /// New owner of item.425 T::CrossAccountId,426 /// Amount of token pieces transfered. Always 1 for NFT.427 u128,428 ),429430 /// Amount pieces of token owned by `sender` was approved for `spender`.431 Approved(432 /// Id of collection to which item is belong.433 CollectionId,434 /// Id of an item.435 TokenId,436 /// Original owner of item.437 T::CrossAccountId,438 /// Id for which the approval was granted.439 T::CrossAccountId,440 /// Amount of token pieces transfered. Always 1 for NFT.441 u128,442 ),443444 /// The colletion property has been set.445 CollectionPropertySet(446 /// Id of collection to which property has been set.447 CollectionId,448 /// The property that was set.449 PropertyKey,450 ),451452 /// The property has been deleted.453 CollectionPropertyDeleted(454 /// Id of collection to which property has been deleted.455 CollectionId,456 /// The property that was deleted.457 PropertyKey,458 ),459460 /// The token property has been set.461 TokenPropertySet(462 /// Identifier of the collection whose token has the property set.463 CollectionId,464 /// The token for which the property was set.465 TokenId,466 /// The property that was set.467 PropertyKey,468 ),469470 /// The token property has been deleted.471 TokenPropertyDeleted(472 /// Identifier of the collection whose token has the property deleted.473 CollectionId,474 /// The token for which the property was deleted.475 TokenId,476 /// The property that was deleted.477 PropertyKey,478 ),479480 /// The colletion property permission has been set.481 PropertyPermissionSet(482 /// Id of collection to which property permission has been set.483 CollectionId,484 /// The property permission that was set.485 PropertyKey,486 ),487 }488489 #[pallet::error]490 pub enum Error<T> {491 /// This collection does not exist.492 CollectionNotFound,493 /// Sender parameter and item owner must be equal.494 MustBeTokenOwner,495 /// No permission to perform action496 NoPermission,497 /// Destroying only empty collections is allowed498 CantDestroyNotEmptyCollection,499 /// Collection is not in mint mode.500 PublicMintingNotAllowed,501 /// Address is not in allow list.502 AddressNotInAllowlist,503504 /// Collection name can not be longer than 63 char.505 CollectionNameLimitExceeded,506 /// Collection description can not be longer than 255 char.507 CollectionDescriptionLimitExceeded,508 /// Token prefix can not be longer than 15 char.509 CollectionTokenPrefixLimitExceeded,510 /// Total collections bound exceeded.511 TotalCollectionsLimitExceeded,512 /// Exceeded max admin count513 CollectionAdminCountExceeded,514 /// Collection limit bounds per collection exceeded515 CollectionLimitBoundsExceeded,516 /// Tried to enable permissions which are only permitted to be disabled517 OwnerPermissionsCantBeReverted,518 /// Collection settings not allowing items transferring519 TransferNotAllowed,520 /// Account token limit exceeded per collection521 AccountTokenLimitExceeded,522 /// Collection token limit exceeded523 CollectionTokenLimitExceeded,524 /// Metadata flag frozen525 MetadataFlagFrozen,526527 /// Item not exists.528 TokenNotFound,529 /// Item balance not enough.530 TokenValueTooLow,531 /// Requested value more than approved.532 ApprovedValueTooLow,533 /// Tried to approve more than owned534 CantApproveMoreThanOwned,535536 /// Can't transfer tokens to ethereum zero address537 AddressIsZero,538 /// Target collection doesn't supports this operation539 UnsupportedOperation,540541 /// Not sufficient funds to perform action542 NotSufficientFounds,543544 /// User not passed nesting rule545 UserIsNotAllowedToNest,546 /// Only tokens from specific collections may nest tokens under this547 SourceCollectionIsNotAllowedToNest,548549 /// Tried to store more data than allowed in collection field550 CollectionFieldSizeExceeded,551552 /// Tried to store more property data than allowed553 NoSpaceForProperty,554555 /// Tried to store more property keys than allowed556 PropertyLimitReached,557558 /// Property key is too long559 PropertyKeyIsTooLong,560561 /// Only ASCII letters, digits, and '_', '-' are allowed562 InvalidCharacterInPropertyKey,563564 /// Empty property keys are forbidden565 EmptyPropertyKey,566567 /// Tried to access an external collection with an internal API568 CollectionIsExternal,569570 /// Tried to access an internal collection with an external API571 CollectionIsInternal,572 }573574 /// Storage of the count of created collections.575 #[pallet::storage]576 pub type CreatedCollectionCount<T> = StorageValue<Value = CollectionId, QueryKind = ValueQuery>;577578 /// Storage of the count of deleted collections.579 #[pallet::storage]580 pub type DestroyedCollectionCount<T> =581 StorageValue<Value = CollectionId, QueryKind = ValueQuery>;582583 /// Storage of collection info.584 #[pallet::storage]585 pub type CollectionById<T> = StorageMap<586 Hasher = Blake2_128Concat,587 Key = CollectionId,588 Value = Collection<<T as frame_system::Config>::AccountId>,589 QueryKind = OptionQuery,590 >;591592 /// Storage of collection properties.593 #[pallet::storage]594 #[pallet::getter(fn collection_properties)]595 pub type CollectionProperties<T> = StorageMap<596 Hasher = Blake2_128Concat,597 Key = CollectionId,598 Value = Properties,599 QueryKind = ValueQuery,600 OnEmpty = up_data_structs::CollectionProperties,601 >;602603 /// Storage of collection properties permissions.604 #[pallet::storage]605 #[pallet::getter(fn property_permissions)]606 pub type CollectionPropertyPermissions<T> = StorageMap<607 Hasher = Blake2_128Concat,608 Key = CollectionId,609 Value = PropertiesPermissionMap,610 QueryKind = ValueQuery,611 >;612613 /// Storage of collection admins count.614 #[pallet::storage]615 pub type AdminAmount<T> = StorageMap<616 Hasher = Blake2_128Concat,617 Key = CollectionId,618 Value = u32,619 QueryKind = ValueQuery,620 >;621622 /// List of collection admins623 #[pallet::storage]624 pub type IsAdmin<T: Config> = StorageNMap<625 Key = (626 Key<Blake2_128Concat, CollectionId>,627 Key<Blake2_128Concat, T::CrossAccountId>,628 ),629 Value = bool,630 QueryKind = ValueQuery,631 >;632633 /// Allowlisted collection users634 #[pallet::storage]635 pub type Allowlist<T: Config> = StorageNMap<636 Key = (637 Key<Blake2_128Concat, CollectionId>,638 Key<Blake2_128Concat, T::CrossAccountId>,639 ),640 Value = bool,641 QueryKind = ValueQuery,642 >;643644 /// Not used by code, exists only to provide some types to metadata.645 #[pallet::storage]646 pub type DummyStorageValue<T: Config> = StorageValue<647 Value = (648 CollectionStats,649 CollectionId,650 TokenId,651 TokenChild,652 PhantomType<(653 TokenData<T::CrossAccountId>,654 RpcCollection<T::AccountId>,655 // RMRK656 RmrkCollectionInfo<T::AccountId>,657 RmrkInstanceInfo<T::AccountId>,658 RmrkResourceInfo,659 RmrkPropertyInfo,660 RmrkBaseInfo<T::AccountId>,661 RmrkPartType,662 RmrkBoundedTheme,663 RmrkNftChild,664 )>,665 ),666 QueryKind = OptionQuery,667 >;668669 #[pallet::hooks]670 impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {671 fn on_runtime_upgrade() -> Weight {672 if StorageVersion::get::<Pallet<T>>() < StorageVersion::new(1) {673 use up_data_structs::{CollectionVersion1, CollectionVersion2};674 <CollectionById<T>>::translate::<CollectionVersion1<T::AccountId>, _>(|id, v| {675 let mut props = Vec::new();676 if !v.offchain_schema.is_empty() {677 props.push(Property {678 key: b"_old_offchainSchema".to_vec().try_into().unwrap(),679 value: v680 .offchain_schema681 .clone()682 .into_inner()683 .try_into()684 .expect("offchain schema too big"),685 });686 }687 if !v.variable_on_chain_schema.is_empty() {688 props.push(Property {689 key: b"_old_variableOnChainSchema".to_vec().try_into().unwrap(),690 value: v691 .variable_on_chain_schema692 .clone()693 .into_inner()694 .try_into()695 .expect("offchain schema too big"),696 });697 }698 if !v.const_on_chain_schema.is_empty() {699 props.push(Property {700 key: b"_old_constOnChainSchema".to_vec().try_into().unwrap(),701 value: v702 .const_on_chain_schema703 .clone()704 .into_inner()705 .try_into()706 .expect("offchain schema too big"),707 });708 }709 props.push(Property {710 key: b"_old_schemaVersion".to_vec().try_into().unwrap(),711 value: match v.schema_version {712 SchemaVersion::ImageURL => b"ImageUrl".as_slice(),713 SchemaVersion::Unique => b"Unique".as_slice(),714 }715 .to_vec()716 .try_into()717 .unwrap(),718 });719 Self::set_scoped_collection_properties(720 id,721 PropertyScope::None,722 props.into_iter(),723 )724 .expect("existing data larger than properties");725 let mut new = CollectionVersion2::from(v.clone());726 new.permissions.access = Some(v.access);727 new.permissions.mint_mode = Some(v.mint_mode);728 Some(new)729 });730 }731732 0733 }734 }735}736737impl<T: Config> Pallet<T> {738 /// Enshure that receiver address is correct.739 ///740 /// Ethereum receiver 0x0000000000000000000000000000000000000000 is reserved, and shouldn't own tokens.741 pub fn ensure_correct_receiver(receiver: &T::CrossAccountId) -> DispatchResult {742 ensure!(743 &T::CrossAccountId::from_eth(H160([0; 20])) != receiver,744 <Error<T>>::AddressIsZero745 );746 Ok(())747 }748749 /// Get a vector of collection admins.750 pub fn adminlist(collection: CollectionId) -> Vec<T::CrossAccountId> {751 <IsAdmin<T>>::iter_prefix((collection,))752 .map(|(a, _)| a)753 .collect()754 }755756 /// Get a vector of users allowed to mint tokens.757 pub fn allowlist(collection: CollectionId) -> Vec<T::CrossAccountId> {758 <Allowlist<T>>::iter_prefix((collection,))759 .map(|(a, _)| a)760 .collect()761 }762763 /// Is `user` allowed to mint token in `collection`.764 pub fn allowed(collection: CollectionId, user: T::CrossAccountId) -> bool {765 <Allowlist<T>>::get((collection, user))766 }767768 /// Get statistics of collections.769 pub fn collection_stats() -> CollectionStats {770 let created = <CreatedCollectionCount<T>>::get();771 let destroyed = <DestroyedCollectionCount<T>>::get();772 CollectionStats {773 created: created.0,774 destroyed: destroyed.0,775 alive: created.0 - destroyed.0,776 }777 }778779 /// Get the effective limits for the collection.780 pub fn effective_collection_limits(collection: CollectionId) -> Option<CollectionLimits> {781 let collection = <CollectionById<T>>::get(collection);782 if collection.is_none() {783 return None;784 }785786 let collection = collection.unwrap();787 let limits = collection.limits;788 let effective_limits = CollectionLimits {789 account_token_ownership_limit: Some(limits.account_token_ownership_limit()),790 sponsored_data_size: Some(limits.sponsored_data_size()),791 sponsored_data_rate_limit: Some(792 limits793 .sponsored_data_rate_limit794 .unwrap_or(SponsoringRateLimit::SponsoringDisabled),795 ),796 token_limit: Some(limits.token_limit()),797 sponsor_transfer_timeout: Some(limits.sponsor_transfer_timeout(798 match collection.mode {799 CollectionMode::NFT => NFT_SPONSOR_TRANSFER_TIMEOUT,800 CollectionMode::Fungible(_) => FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,801 CollectionMode::ReFungible => REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,802 },803 )),804 sponsor_approve_timeout: Some(limits.sponsor_approve_timeout()),805 owner_can_transfer: Some(limits.owner_can_transfer()),806 owner_can_destroy: Some(limits.owner_can_destroy()),807 transfers_enabled: Some(limits.transfers_enabled()),808 };809810 Some(effective_limits)811 }812813 /// Returns information about the `collection` adapted for rpc.814 pub fn rpc_collection(collection: CollectionId) -> Option<RpcCollection<T::AccountId>> {815 let Collection {816 name,817 description,818 owner,819 mode,820 token_prefix,821 sponsorship,822 limits,823 permissions,824 external_collection,825 } = <CollectionById<T>>::get(collection)?;826827 let token_property_permissions = <CollectionPropertyPermissions<T>>::get(collection)828 .into_iter()829 .map(|(key, permission)| PropertyKeyPermission { key, permission })830 .collect();831832 let properties = <CollectionProperties<T>>::get(collection)833 .into_iter()834 .map(|(key, value)| Property { key, value })835 .collect();836837 let permissions = CollectionPermissions {838 access: Some(permissions.access()),839 mint_mode: Some(permissions.mint_mode()),840 nesting: Some(permissions.nesting().clone()),841 };842843 Some(RpcCollection {844 name: name.into_inner(),845 description: description.into_inner(),846 owner,847 mode,848 token_prefix: token_prefix.into_inner(),849 sponsorship,850 limits,851 permissions,852 token_property_permissions,853 properties,854 read_only: external_collection,855 })856 }857}858859macro_rules! limit_default {860 ($old:ident, $new:ident, $($field:ident $(($arg:expr))? => $check:expr),* $(,)?) => {{861 $(862 if let Some($new) = $new.$field {863 let $old = $old.$field($($arg)?);864 let _ = $new;865 let _ = $old;866 $check867 } else {868 $new.$field = $old.$field869 }870 )*871 }};872}873macro_rules! limit_default_clone {874 ($old:ident, $new:ident, $($field:ident $(($arg:expr))? => $check:expr),* $(,)?) => {{875 $(876 if let Some($new) = $new.$field.clone() {877 let $old = $old.$field($($arg)?);878 let _ = $new;879 let _ = $old;880 $check881 } else {882 $new.$field = $old.$field.clone()883 }884 )*885 }};886}887888impl<T: Config> Pallet<T> {889 /// Create new collection.890 ///891 /// * `owner` - The owner of the collection.892 /// * `data` - Description of the created collection.893 /// * `is_external` - Marks that collection managet by not "Unique network".894 pub fn init_collection(895 owner: T::CrossAccountId,896 data: CreateCollectionData<T::AccountId>,897 is_external: bool,898 ) -> Result<CollectionId, DispatchError> {899 {900 ensure!(901 data.token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH as usize,902 Error::<T>::CollectionTokenPrefixLimitExceeded903 );904 }905906 let created_count = <CreatedCollectionCount<T>>::get()907 .0908 .checked_add(1)909 .ok_or(ArithmeticError::Overflow)?;910 let destroyed_count = <DestroyedCollectionCount<T>>::get().0;911 let id = CollectionId(created_count);912913 // bound Total number of collections914 ensure!(915 created_count - destroyed_count <= COLLECTION_NUMBER_LIMIT,916 <Error<T>>::TotalCollectionsLimitExceeded917 );918919 // =========920921 let collection = Collection {922 owner: owner.as_sub().clone(),923 name: data.name,924 mode: data.mode.clone(),925 description: data.description,926 token_prefix: data.token_prefix,927 sponsorship: data928 .pending_sponsor929 .map(SponsorshipState::Unconfirmed)930 .unwrap_or_default(),931 limits: data932 .limits933 .map(|limits| Self::clamp_limits(data.mode.clone(), &Default::default(), limits))934 .unwrap_or_else(|| Ok(CollectionLimits::default()))?,935 permissions: data936 .permissions937 .map(|permissions| {938 Self::clamp_permissions(data.mode.clone(), &Default::default(), permissions)939 })940 .unwrap_or_else(|| Ok(CollectionPermissions::default()))?,941 external_collection: is_external,942 };943944 let mut collection_properties = up_data_structs::CollectionProperties::get();945 collection_properties946 .try_set_from_iter(data.properties.into_iter())947 .map_err(<Error<T>>::from)?;948949 CollectionProperties::<T>::insert(id, collection_properties);950951 let mut token_props_permissions = PropertiesPermissionMap::new();952 token_props_permissions953 .try_set_from_iter(data.token_property_permissions.into_iter())954 .map_err(<Error<T>>::from)?;955956 CollectionPropertyPermissions::<T>::insert(id, token_props_permissions);957958 // Take a (non-refundable) deposit of collection creation959 {960 let mut imbalance =961 <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();962 imbalance.subsume(963 <<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(964 &T::TreasuryAccountId::get(),965 T::CollectionCreationPrice::get(),966 ),967 );968 <T as Config>::Currency::settle(969 &owner.as_sub(),970 imbalance,971 WithdrawReasons::TRANSFER,972 ExistenceRequirement::KeepAlive,973 )974 .map_err(|_| Error::<T>::NotSufficientFounds)?;975 }976977 <CreatedCollectionCount<T>>::put(created_count);978 <Pallet<T>>::deposit_event(Event::CollectionCreated(979 id,980 data.mode.id(),981 owner.as_sub().clone(),982 ));983 <PalletEvm<T>>::deposit_log(984 erc::CollectionHelpersEvents::CollectionCreated {985 owner: *owner.as_eth(),986 collection_id: eth::collection_id_to_address(id),987 }988 .to_log(T::ContractAddress::get()),989 );990 <CollectionById<T>>::insert(id, collection);991 Ok(id)992 }993994 /// Destroy collection.995 ///996 /// * `collection` - Collection handler.997 /// * `sender` - The owner or administrator of the collection.998 pub fn destroy_collection(999 collection: CollectionHandle<T>,1000 sender: &T::CrossAccountId,1001 ) -> DispatchResult {1002 ensure!(1003 collection.limits.owner_can_destroy(),1004 <Error<T>>::NoPermission,1005 );1006 collection.check_is_owner(sender)?;10071008 let destroyed_collections = <DestroyedCollectionCount<T>>::get()1009 .01010 .checked_add(1)1011 .ok_or(ArithmeticError::Overflow)?;10121013 // =========10141015 <DestroyedCollectionCount<T>>::put(destroyed_collections);1016 <CollectionById<T>>::remove(collection.id);1017 <AdminAmount<T>>::remove(collection.id);1018 <IsAdmin<T>>::remove_prefix((collection.id,), None);1019 <Allowlist<T>>::remove_prefix((collection.id,), None);1020 <CollectionProperties<T>>::remove(collection.id);10211022 <Pallet<T>>::deposit_event(Event::CollectionDestroyed(collection.id));1023 Ok(())1024 }10251026 /// Set collection property.1027 ///1028 /// * `collection` - Collection handler.1029 /// * `sender` - The owner or administrator of the collection.1030 /// * `property` - The property to set.1031 pub fn set_collection_property(1032 collection: &CollectionHandle<T>,1033 sender: &T::CrossAccountId,1034 property: Property,1035 ) -> DispatchResult {1036 collection.check_is_owner_or_admin(sender)?;10371038 CollectionProperties::<T>::try_mutate(collection.id, |properties| {1039 let property = property.clone();1040 properties.try_set(property.key, property.value)1041 })1042 .map_err(<Error<T>>::from)?;10431044 Self::deposit_event(Event::CollectionPropertySet(collection.id, property.key));10451046 Ok(())1047 }10481049 /// Set scouped collection property.1050 ///1051 /// * `collection_id` - ID of the collection for which the property is being set.1052 /// * `scope` - Property scope.1053 /// * `property` - The property to set.1054 pub fn set_scoped_collection_property(1055 collection_id: CollectionId,1056 scope: PropertyScope,1057 property: Property,1058 ) -> DispatchResult {1059 CollectionProperties::<T>::try_mutate(collection_id, |properties| {1060 properties.try_scoped_set(scope, property.key, property.value)1061 })1062 .map_err(<Error<T>>::from)?;10631064 Ok(())1065 }10661067 /// Set scouped collection properties.1068 ///1069 /// * `collection_id` - ID of the collection for which the properties is being set.1070 /// * `scope` - Property scope.1071 /// * `properties` - The properties to set.1072 pub fn set_scoped_collection_properties(1073 collection_id: CollectionId,1074 scope: PropertyScope,1075 properties: impl Iterator<Item = Property>,1076 ) -> DispatchResult {1077 CollectionProperties::<T>::try_mutate(collection_id, |stored_properties| {1078 stored_properties.try_scoped_set_from_iter(scope, properties)1079 })1080 .map_err(<Error<T>>::from)?;10811082 Ok(())1083 }10841085 /// Set collection properties.1086 ///1087 /// * `collection` - Collection handler.1088 /// * `sender` - The owner or administrator of the collection.1089 /// * `properties` - The properties to set.1090 #[transactional]1091 pub fn set_collection_properties(1092 collection: &CollectionHandle<T>,1093 sender: &T::CrossAccountId,1094 properties: Vec<Property>,1095 ) -> DispatchResult {1096 for property in properties {1097 Self::set_collection_property(collection, sender, property)?;1098 }10991100 Ok(())1101 }11021103 /// Delete collection property.1104 ///1105 /// * `collection` - Collection handler.1106 /// * `sender` - The owner or administrator of the collection.1107 /// * `property` - The property to delete.1108 pub fn delete_collection_property(1109 collection: &CollectionHandle<T>,1110 sender: &T::CrossAccountId,1111 property_key: PropertyKey,1112 ) -> DispatchResult {1113 collection.check_is_owner_or_admin(sender)?;11141115 CollectionProperties::<T>::try_mutate(collection.id, |properties| {1116 properties.remove(&property_key)1117 })1118 .map_err(<Error<T>>::from)?;11191120 Self::deposit_event(Event::CollectionPropertyDeleted(1121 collection.id,1122 property_key,1123 ));11241125 Ok(())1126 }11271128 /// Delete collection properties.1129 ///1130 /// * `collection` - Collection handler.1131 /// * `sender` - The owner or administrator of the collection.1132 /// * `properties` - The properties to delete.1133 #[transactional]1134 pub fn delete_collection_properties(1135 collection: &CollectionHandle<T>,1136 sender: &T::CrossAccountId,1137 property_keys: Vec<PropertyKey>,1138 ) -> DispatchResult {1139 for key in property_keys {1140 Self::delete_collection_property(collection, sender, key)?;1141 }11421143 Ok(())1144 }11451146 /// Set collection propetry permission without any checks.1147 ///1148 /// Used for migrations.1149 ///1150 /// * `collection` - Collection handler.1151 /// * `property_permissions` - Property permissions.1152 pub fn set_property_permission_unchecked(1153 collection: CollectionId,1154 property_permission: PropertyKeyPermission,1155 ) -> DispatchResult {1156 <CollectionPropertyPermissions<T>>::try_mutate(collection, |permissions| {1157 permissions.try_set(property_permission.key, property_permission.permission)1158 })1159 .map_err(<Error<T>>::from)?;1160 Ok(())1161 }11621163 /// Set collection property permission.1164 ///1165 /// * `collection` - Collection handler.1166 /// * `sender` - The owner or administrator of the collection.1167 /// * `property_permission` - Property permission.1168 pub fn set_property_permission(1169 collection: &CollectionHandle<T>,1170 sender: &T::CrossAccountId,1171 property_permission: PropertyKeyPermission,1172 ) -> DispatchResult {1173 collection.check_is_owner_or_admin(sender)?;11741175 let all_permissions = CollectionPropertyPermissions::<T>::get(collection.id);1176 let current_permission = all_permissions.get(&property_permission.key);1177 if matches![1178 current_permission,1179 Some(PropertyPermission { mutable: false, .. })1180 ] {1181 return Err(<Error<T>>::NoPermission.into());1182 }11831184 CollectionPropertyPermissions::<T>::try_mutate(collection.id, |permissions| {1185 let property_permission = property_permission.clone();1186 permissions.try_set(property_permission.key, property_permission.permission)1187 })1188 .map_err(<Error<T>>::from)?;11891190 Self::deposit_event(Event::PropertyPermissionSet(1191 collection.id,1192 property_permission.key,1193 ));11941195 Ok(())1196 }11971198 /// Set token property permission.1199 ///1200 /// * `collection` - Collection handler.1201 /// * `sender` - The owner or administrator of the collection.1202 /// * `property_permissions` - Property permissions.1203 #[transactional]1204 pub fn set_token_property_permissions(1205 collection: &CollectionHandle<T>,1206 sender: &T::CrossAccountId,1207 property_permissions: Vec<PropertyKeyPermission>,1208 ) -> DispatchResult {1209 for prop_pemission in property_permissions {1210 Self::set_property_permission(collection, sender, prop_pemission)?;1211 }12121213 Ok(())1214 }12151216 /// Get collection property.1217 pub fn get_collection_property(1218 collection_id: CollectionId,1219 key: &PropertyKey,1220 ) -> Option<PropertyValue> {1221 Self::collection_properties(collection_id).get(key).cloned()1222 }12231224 /// Convert byte vector to property key vector.1225 pub fn bytes_keys_to_property_keys(1226 keys: Vec<Vec<u8>>,1227 ) -> Result<Vec<PropertyKey>, DispatchError> {1228 keys.into_iter()1229 .map(|key| -> Result<PropertyKey, DispatchError> {1230 key.try_into()1231 .map_err(|_| <Error<T>>::PropertyKeyIsTooLong.into())1232 })1233 .collect::<Result<Vec<PropertyKey>, DispatchError>>()1234 }12351236 /// Get properties according to given keys.1237 pub fn filter_collection_properties(1238 collection_id: CollectionId,1239 keys: Option<Vec<PropertyKey>>,1240 ) -> Result<Vec<Property>, DispatchError> {1241 let properties = Self::collection_properties(collection_id);12421243 let properties = keys1244 .map(|keys| {1245 keys.into_iter()1246 .filter_map(|key| {1247 properties.get(&key).map(|value| Property {1248 key,1249 value: value.clone(),1250 })1251 })1252 .collect()1253 })1254 .unwrap_or_else(|| {1255 properties1256 .into_iter()1257 .map(|(key, value)| Property { key, value })1258 .collect()1259 });12601261 Ok(properties)1262 }12631264 /// Get property permissions according to given keys.1265 pub fn filter_property_permissions(1266 collection_id: CollectionId,1267 keys: Option<Vec<PropertyKey>>,1268 ) -> Result<Vec<PropertyKeyPermission>, DispatchError> {1269 let permissions = Self::property_permissions(collection_id);12701271 let key_permissions = keys1272 .map(|keys| {1273 keys.into_iter()1274 .filter_map(|key| {1275 permissions1276 .get(&key)1277 .map(|permission| PropertyKeyPermission {1278 key,1279 permission: permission.clone(),1280 })1281 })1282 .collect()1283 })1284 .unwrap_or_else(|| {1285 permissions1286 .into_iter()1287 .map(|(key, permission)| PropertyKeyPermission { key, permission })1288 .collect()1289 });12901291 Ok(key_permissions)1292 }12931294 /// Toggle `user` participation in the `collection`'s allow list.1295 pub fn toggle_allowlist(1296 collection: &CollectionHandle<T>,1297 sender: &T::CrossAccountId,1298 user: &T::CrossAccountId,1299 allowed: bool,1300 ) -> DispatchResult {1301 collection.check_is_owner_or_admin(sender)?;13021303 // =========13041305 if allowed {1306 <Allowlist<T>>::insert((collection.id, user), true);1307 } else {1308 <Allowlist<T>>::remove((collection.id, user));1309 }13101311 Ok(())1312 }13131314 /// Toggle `user` participation in the `collection`'s admin list.1315 pub fn toggle_admin(1316 collection: &CollectionHandle<T>,1317 sender: &T::CrossAccountId,1318 user: &T::CrossAccountId,1319 admin: bool,1320 ) -> DispatchResult {1321 collection.check_is_owner(sender)?;13221323 let was_admin = <IsAdmin<T>>::get((collection.id, user));1324 if was_admin == admin {1325 return Ok(());1326 }1327 let amount = <AdminAmount<T>>::get(collection.id);13281329 if admin {1330 let amount = amount1331 .checked_add(1)1332 .ok_or(<Error<T>>::CollectionAdminCountExceeded)?;1333 ensure!(1334 amount <= Self::collection_admins_limit(),1335 <Error<T>>::CollectionAdminCountExceeded,1336 );13371338 // =========13391340 <AdminAmount<T>>::insert(collection.id, amount);1341 <IsAdmin<T>>::insert((collection.id, user), true);1342 } else {1343 <AdminAmount<T>>::insert(collection.id, amount.saturating_sub(1));1344 <IsAdmin<T>>::remove((collection.id, user));1345 }13461347 Ok(())1348 }13491350 /// Merge set fields from `new_limit` to `old_limit`.1351 pub fn clamp_limits(1352 mode: CollectionMode,1353 old_limit: &CollectionLimits,1354 mut new_limit: CollectionLimits,1355 ) -> Result<CollectionLimits, DispatchError> {1356 let limits = old_limit;1357 limit_default!(old_limit, new_limit,1358 account_token_ownership_limit => ensure!(1359 new_limit <= MAX_TOKEN_OWNERSHIP,1360 <Error<T>>::CollectionLimitBoundsExceeded,1361 ),1362 sponsored_data_size => ensure!(1363 new_limit <= CUSTOM_DATA_LIMIT,1364 <Error<T>>::CollectionLimitBoundsExceeded,1365 ),13661367 sponsored_data_rate_limit => {},1368 token_limit => ensure!(1369 old_limit >= new_limit && new_limit > 0,1370 <Error<T>>::CollectionTokenLimitExceeded1371 ),13721373 sponsor_transfer_timeout(match mode {1374 CollectionMode::NFT => NFT_SPONSOR_TRANSFER_TIMEOUT,1375 CollectionMode::Fungible(_) => FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,1376 CollectionMode::ReFungible => REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,1377 }) => ensure!(1378 new_limit <= MAX_SPONSOR_TIMEOUT,1379 <Error<T>>::CollectionLimitBoundsExceeded,1380 ),1381 sponsor_approve_timeout => {},1382 owner_can_transfer => ensure!(1383 !limits.owner_can_transfer_instaled() ||1384 old_limit || !new_limit,1385 <Error<T>>::OwnerPermissionsCantBeReverted,1386 ),1387 owner_can_destroy => ensure!(1388 old_limit || !new_limit,1389 <Error<T>>::OwnerPermissionsCantBeReverted,1390 ),1391 transfers_enabled => {},1392 );1393 Ok(new_limit)1394 }13951396 /// Merge set fields from `new_permission` to `old_permission`.1397 pub fn clamp_permissions(1398 _mode: CollectionMode,1399 old_permission: &CollectionPermissions,1400 mut new_permission: CollectionPermissions,1401 ) -> Result<CollectionPermissions, DispatchError> {1402 limit_default_clone!(old_permission, new_permission,1403 access => {},1404 mint_mode => {},1405 nesting => { /* todo check for permissive, if only it gets out of benchmarks */ },1406 );1407 Ok(new_permission)1408 }1409}14101411/// Indicates unsupported methods by returning [Error::UnsupportedOperation].1412#[macro_export]1413macro_rules! unsupported {1414 () => {1415 Err(<Error<T>>::UnsupportedOperation.into())1416 };1417}14181419/// Return weights for various worst-case operations.1420pub trait CommonWeightInfo<CrossAccountId> {1421 /// Weight of item creation.1422 fn create_item() -> Weight;14231424 /// Weight of items creation.1425 fn create_multiple_items(amount: &[CreateItemData]) -> Weight;14261427 /// Weight of items creation.1428 fn create_multiple_items_ex(cost: &CreateItemExData<CrossAccountId>) -> Weight;14291430 /// The weight of the burning item.1431 fn burn_item() -> Weight;14321433 /// Property setting weight.1434 ///1435 /// * `amount`- The number of properties to set.1436 fn set_collection_properties(amount: u32) -> Weight;14371438 /// Collection property deletion weight.1439 ///1440 /// * `amount`- The number of properties to set.1441 fn delete_collection_properties(amount: u32) -> Weight;14421443 /// Token property setting weight.1444 ///1445 /// * `amount`- The number of properties to set.1446 fn set_token_properties(amount: u32) -> Weight;14471448 /// Token property deletion weight.1449 ///1450 /// * `amount`- The number of properties to delete.1451 fn delete_token_properties(amount: u32) -> Weight;14521453 /// Token property permissions set weight.1454 ///1455 /// * `amount`- The number of property permissions to set.1456 fn set_token_property_permissions(amount: u32) -> Weight;14571458 /// Transfer price of the token or its parts.1459 fn transfer() -> Weight;14601461 /// The price of setting the permission of the operation from another user.1462 fn approve() -> Weight;14631464 /// Transfer price from another user.1465 fn transfer_from() -> Weight;14661467 /// The price of burning a token from another user.1468 fn burn_from() -> Weight;14691470 /// Differs from burn_item in case of Fungible and Refungible, as it should burn1471 /// whole users's balance.1472 ///1473 /// This method shouldn't be used directly, as it doesn't count breadth price, use [burn_recursively](CommonWeightInfo::burn_recursively) instead1474 fn burn_recursively_self_raw() -> Weight;14751476 /// Cost of iterating over `amount` children while burning, without counting child burning itself.1477 ///1478 /// This method shouldn't be used directly, as it doesn't count depth price, use [burn_recursively](CommonWeightInfo::burn_recursively) instead1479 fn burn_recursively_breadth_raw(amount: u32) -> Weight;14801481 /// The price of recursive burning a token.1482 ///1483 /// `max_selfs` - The maximum burning weight of the token itself.1484 /// `max_breadth` - The maximum number of nested tokens to burn.1485 fn burn_recursively(max_selfs: u32, max_breadth: u32) -> Weight {1486 Self::burn_recursively_self_raw()1487 .saturating_mul(max_selfs.max(1) as u64)1488 .saturating_add(Self::burn_recursively_breadth_raw(max_breadth))1489 }1490}14911492/// Weight info extension trait for refungible pallet.1493pub trait RefungibleExtensionsWeightInfo {1494 /// Weight of token repartition.1495 fn repartition() -> Weight;1496}14971498/// Common collection operations.1499///1500/// It wraps methods in Fungible, Nonfungible and Refungible pallets1501/// and adds weight info.1502pub trait CommonCollectionOperations<T: Config> {1503 /// Create token.1504 ///1505 /// * `sender` - The user who mint the token and pays for the transaction.1506 /// * `to` - The user who will own the token.1507 /// * `data` - Token data.1508 /// * `nesting_budget` - A budget that can be spent on nesting tokens.1509 fn create_item(1510 &self,1511 sender: T::CrossAccountId,1512 to: T::CrossAccountId,1513 data: CreateItemData,1514 nesting_budget: &dyn Budget,1515 ) -> DispatchResultWithPostInfo;15161517 /// Create multiple tokens.1518 ///1519 /// * `sender` - The user who mint the token and pays for the transaction.1520 /// * `to` - The user who will own the token.1521 /// * `data` - Token data.1522 /// * `nesting_budget` - A budget that can be spent on nesting tokens.1523 fn create_multiple_items(1524 &self,1525 sender: T::CrossAccountId,1526 to: T::CrossAccountId,1527 data: Vec<CreateItemData>,1528 nesting_budget: &dyn Budget,1529 ) -> DispatchResultWithPostInfo;15301531 /// Create multiple tokens.1532 ///1533 /// * `sender` - The user who mint the token and pays for the transaction.1534 /// * `to` - The user who will own the token.1535 /// * `data` - Token data.1536 /// * `nesting_budget` - A budget that can be spent on nesting tokens.1537 fn create_multiple_items_ex(1538 &self,1539 sender: T::CrossAccountId,1540 data: CreateItemExData<T::CrossAccountId>,1541 nesting_budget: &dyn Budget,1542 ) -> DispatchResultWithPostInfo;15431544 /// Burn token.1545 ///1546 /// * `sender` - The user who owns the token.1547 /// * `token` - Token id that will burned.1548 /// * `amount` - The number of parts of the token that will be burned.1549 fn burn_item(1550 &self,1551 sender: T::CrossAccountId,1552 token: TokenId,1553 amount: u128,1554 ) -> DispatchResultWithPostInfo;15551556 /// Burn token and all nested tokens recursievly.1557 ///1558 /// * `sender` - The user who owns the token.1559 /// * `token` - Token id that will burned.1560 /// * `self_budget` - The budget that can be spent on burning tokens.1561 /// * `breadth_budget` - The budget that can be spent on burning nested tokens.1562 fn burn_item_recursively(1563 &self,1564 sender: T::CrossAccountId,1565 token: TokenId,1566 self_budget: &dyn Budget,1567 breadth_budget: &dyn Budget,1568 ) -> DispatchResultWithPostInfo;15691570 /// Set collection properties.1571 ///1572 /// * `sender` - Must be either the owner of the collection or its admin.1573 /// * `properties` - Properties to be set.1574 fn set_collection_properties(1575 &self,1576 sender: T::CrossAccountId,1577 properties: Vec<Property>,1578 ) -> DispatchResultWithPostInfo;15791580 /// Delete collection properties.1581 ///1582 /// * `sender` - Must be either the owner of the collection or its admin.1583 /// * `properties` - The properties to be removed.1584 fn delete_collection_properties(1585 &self,1586 sender: &T::CrossAccountId,1587 property_keys: Vec<PropertyKey>,1588 ) -> DispatchResultWithPostInfo;15891590 /// Set token properties.1591 ///1592 /// The appropriate [`PropertyPermission`] for the token property1593 /// must be set with [`Self::set_token_property_permissions`].1594 ///1595 /// * `sender` - Must be either the owner of the token or its admin.1596 /// * `token_id` - The token for which the properties are being set.1597 /// * `properties` - Properties to be set.1598 /// * `budget` - Budget for setting properties.1599 fn set_token_properties(1600 &self,1601 sender: T::CrossAccountId,1602 token_id: TokenId,1603 properties: Vec<Property>,1604 budget: &dyn Budget,1605 ) -> DispatchResultWithPostInfo;16061607 /// Remove token properties.1608 ///1609 /// The appropriate [`PropertyPermission`] for the token property1610 /// must be set with [`Self::set_token_property_permissions`].1611 ///1612 /// * `sender` - Must be either the owner of the token or its admin.1613 /// * `token_id` - The token for which the properties are being remove.1614 /// * `property_keys` - Keys to remove corresponding properties.1615 /// * `budget` - Budget for removing properties.1616 fn delete_token_properties(1617 &self,1618 sender: T::CrossAccountId,1619 token_id: TokenId,1620 property_keys: Vec<PropertyKey>,1621 budget: &dyn Budget,1622 ) -> DispatchResultWithPostInfo;16231624 /// Set token property permissions.1625 ///1626 /// * `sender` - Must be either the owner of the token or its admin.1627 /// * `token_id` - The token for which the properties are being set.1628 /// * `properties` - Properties to be set.1629 /// * `budget` - Budget for setting properties.1630 fn set_token_property_permissions(1631 &self,1632 sender: &T::CrossAccountId,1633 property_permissions: Vec<PropertyKeyPermission>,1634 ) -> DispatchResultWithPostInfo;16351636 /// Transfer amount of token pieces.1637 ///1638 /// * `sender` - Donor user.1639 /// * `to` - Recepient user.1640 /// * `token` - The token of which parts are being sent.1641 /// * `amount` - The number of parts of the token that will be transferred.1642 /// * `budget` - The maximum budget that can be spent on the transfer.1643 fn transfer(1644 &self,1645 sender: T::CrossAccountId,1646 to: T::CrossAccountId,1647 token: TokenId,1648 amount: u128,1649 budget: &dyn Budget,1650 ) -> DispatchResultWithPostInfo;16511652 /// Grant access to another account to transfer parts of the token owned by the calling user via [Self::transfer_from].1653 ///1654 /// * `sender` - The user who grants access to the token.1655 /// * `spender` - The user to whom the rights are granted.1656 /// * `token` - The token to which access is granted.1657 /// * `amount` - The amount of pieces that another user can dispose of.1658 fn approve(1659 &self,1660 sender: T::CrossAccountId,1661 spender: T::CrossAccountId,1662 token: TokenId,1663 amount: u128,1664 ) -> DispatchResultWithPostInfo;16651666 /// Send parts of a token owned by another user.1667 ///1668 /// Before calling this method, you must grant rights to the calling user via [`Self::approve`].1669 ///1670 /// * `sender` - The user who must have access to the token (see [`Self::approve`]).1671 /// * `from` - The user who owns the token.1672 /// * `to` - Recepient user.1673 /// * `token` - The token of which parts are being sent.1674 /// * `amount` - The number of parts of the token that will be transferred.1675 /// * `budget` - The maximum budget that can be spent on the transfer.1676 fn transfer_from(1677 &self,1678 sender: T::CrossAccountId,1679 from: T::CrossAccountId,1680 to: T::CrossAccountId,1681 token: TokenId,1682 amount: u128,1683 budget: &dyn Budget,1684 ) -> DispatchResultWithPostInfo;16851686 /// Burn parts of a token owned by another user.1687 ///1688 /// Before calling this method, you must grant rights to the calling user via [`Self::approve`].1689 ///1690 /// * `sender` - The user who must have access to the token (see [`Self::approve`]).1691 /// * `from` - The user who owns the token.1692 /// * `token` - The token of which parts are being sent.1693 /// * `amount` - The number of parts of the token that will be transferred.1694 /// * `budget` - The maximum budget that can be spent on the burn.1695 fn burn_from(1696 &self,1697 sender: T::CrossAccountId,1698 from: T::CrossAccountId,1699 token: TokenId,1700 amount: u128,1701 budget: &dyn Budget,1702 ) -> DispatchResultWithPostInfo;17031704 /// Check permission to nest token.1705 ///1706 /// * `sender` - The user who initiated the check.1707 /// * `from` - The token that is checked for embedding.1708 /// * `under` - Token under which to check.1709 /// * `budget` - The maximum budget that can be spent on the check.1710 fn check_nesting(1711 &self,1712 sender: T::CrossAccountId,1713 from: (CollectionId, TokenId),1714 under: TokenId,1715 budget: &dyn Budget,1716 ) -> DispatchResult;17171718 /// Nest one token into another.1719 ///1720 /// * `under` - Token holder.1721 /// * `to_nest` - Nested token.1722 fn nest(&self, under: TokenId, to_nest: (CollectionId, TokenId));17231724 /// Unnest token.1725 ///1726 /// * `under` - Token holder.1727 /// * `to_nest` - Token to unnest.1728 fn unnest(&self, under: TokenId, to_nest: (CollectionId, TokenId));17291730 /// Get all user tokens.1731 ///1732 /// * `account` - Account for which you need to get tokens.1733 fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId>;17341735 /// Get all the tokens in the collection.1736 fn collection_tokens(&self) -> Vec<TokenId>;17371738 /// Check if the token exists.1739 ///1740 /// * `token` - Id token to check.1741 fn token_exists(&self, token: TokenId) -> bool;17421743 /// Get the id of the last minted token.1744 fn last_token_id(&self) -> TokenId;17451746 /// Get the owner of the token.1747 ///1748 /// * `token` - The token for which you need to find out the owner.1749 fn token_owner(&self, token: TokenId) -> Option<T::CrossAccountId>;17501751 /// Get the value of the token property by key.1752 ///1753 /// * `token` - Token with the property to get.1754 /// * `key` - Property name.1755 fn token_property(&self, token_id: TokenId, key: &PropertyKey) -> Option<PropertyValue>;17561757 /// Get a set of token properties by key vector.1758 ///1759 /// * `token` - Token with the property to get.1760 /// * `keys` - Vector of property keys. If this parameter is [None](sp_std::result::Result),1761 /// then all properties are returned.1762 fn token_properties(&self, token: TokenId, keys: Option<Vec<PropertyKey>>) -> Vec<Property>;17631764 /// Amount of unique collection tokens1765 fn total_supply(&self) -> u32;17661767 /// Amount of different tokens account has.1768 ///1769 /// * `account` - The account for which need to get the balance.1770 fn account_balance(&self, account: T::CrossAccountId) -> u32;17711772 /// Amount of specific token account have.1773 fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128;17741775 /// Amount of token pieces1776 fn total_pieces(&self, token: TokenId) -> Option<u128>;17771778 /// Get the number of parts of the token that a trusted user can manage.1779 ///1780 /// * `sender` - Trusted user.1781 /// * `spender` - Owner of the token.1782 /// * `token` - The token for which to get the value.1783 fn allowance(1784 &self,1785 sender: T::CrossAccountId,1786 spender: T::CrossAccountId,1787 token: TokenId,1788 ) -> u128;17891790 /// Get extension for RFT collection.1791 fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>>;1792}17931794/// Extension for RFT collection.1795pub trait RefungibleExtensions<T>1796where1797 T: Config,1798{1799 /// Change the number of parts of the token.1800 ///1801 /// When the value changes down, this function is equivalent to burning parts of the token.1802 ///1803 /// * `sender` - The user calling the repartition operation. Must be the owner of the token.1804 /// * `token` - The token for which you want to change the number of parts.1805 /// * `amount` - The new value of the parts of the token.1806 fn repartition(1807 &self,1808 sender: &T::CrossAccountId,1809 token: TokenId,1810 amount: u128,1811 ) -> DispatchResultWithPostInfo;1812}18131814/// Merge [`DispatchResult`] with [`Weight`] into [`DispatchResultWithPostInfo`].1815///1816/// Used for [`CommonCollectionOperations`] implementations and flexible enough to do so.1817pub fn with_weight(res: DispatchResult, weight: Weight) -> DispatchResultWithPostInfo {1818 let post_info = PostDispatchInfo {1819 actual_weight: Some(weight),1820 pays_fee: Pays::Yes,1821 };1822 match res {1823 Ok(()) => Ok(post_info),1824 Err(error) => Err(DispatchErrorWithPostInfo { post_info, error }),1825 }1826}18271828impl<T: Config> From<PropertiesError> for Error<T> {1829 fn from(error: PropertiesError) -> Self {1830 match error {1831 PropertiesError::NoSpaceForProperty => Self::NoSpaceForProperty,1832 PropertiesError::PropertyLimitReached => Self::PropertyLimitReached,1833 PropertiesError::InvalidCharacterInPropertyKey => Self::InvalidCharacterInPropertyKey,1834 PropertiesError::PropertyKeyIsTooLong => Self::PropertyKeyIsTooLong,1835 PropertiesError::EmptyPropertyKey => Self::EmptyPropertyKey,1836 }1837 }1838}