git.delta.rocks / unique-network / refs/commits / f549b53e866e

1// 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 functionality for handling collections.20//!21//! ## Overview22//!23//! The Common pallet provides functions for:24//!25//! - Setting and approving collection soponsor.26//! - Get\set\delete allow list.27//! - Get\set\delete collection properties.28//! - Get\set\delete collection property permissions.29//! - Get\set\delete token property permissions.30//! - Get\set\delete collection administrators.31//! - Checking access permissions.32//! - Provides an interface for common collection operations for different collection types.33//! - Provides dispatching for implementations of common collection operations, see [dispatch] module.34//! - Provides functionality of collection into evm, see [erc] and [eth] module.35//!36//! ### Terminology37//! **Collection sponsor** - For the collection, you can set a sponsor, at whose expense it will38//! be possible to mint tokens.39//!40//! **Allow list** - List of users who have the right to minting tokens.41//!42//! **Collection properties** - Collection properties are simply key-value stores where various43//! metadata can be placed.44//!45//! **Collection property permissions** - For each property in the collection can be set permission46//! to change, see [PropertyPermission].47//!48//! **Permissions on token properties** - Similar to _permissions on collection properties_,49//! only restrictions apply to token properties.50//!51//! **Collection administrator** - For a collection, you can set administrators who have the right52//! to most actions on the collection.5354#![warn(missing_docs)]55#![cfg_attr(not(feature = "std"), no_std)]56extern crate alloc;5758use core::ops::{Deref, DerefMut};59use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};60use sp_std::vec::Vec;61use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};62use evm_coder::ToLog;63use frame_support::{64	dispatch::{DispatchErrorWithPostInfo, DispatchResultWithPostInfo, Weight, PostDispatchInfo},65	ensure,66	traits::{Imbalance, Get, Currency, WithdrawReasons, ExistenceRequirement},67	weights::Pays,68	transactional,69};70use pallet_evm::GasWeightMapping;71use up_data_structs::{72	COLLECTION_NUMBER_LIMIT,73	Collection,74	RpcCollection,75	CollectionId,76	CreateItemData,77	MAX_TOKEN_PREFIX_LENGTH,78	COLLECTION_ADMINS_LIMIT,79	TokenId,80	TokenChild,81	CollectionStats,82	MAX_TOKEN_OWNERSHIP,83	CollectionMode,84	NFT_SPONSOR_TRANSFER_TIMEOUT,85	FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,86	REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,87	MAX_SPONSOR_TIMEOUT,88	CUSTOM_DATA_LIMIT,89	CollectionLimits,90	CreateCollectionData,91	SponsorshipState,92	CreateItemExData,93	SponsoringRateLimit,94	budget::Budget,95	PhantomType,96	Property,97	Properties,98	PropertiesPermissionMap,99	PropertyKey,100	PropertyValue,101	PropertyPermission,102	PropertiesError,103	PropertyKeyPermission,104	TokenData,105	TrySetProperty,106	PropertyScope,107	// RMRK108	RmrkCollectionInfo,109	RmrkInstanceInfo,110	RmrkResourceInfo,111	RmrkPropertyInfo,112	RmrkBaseInfo,113	RmrkPartType,114	RmrkBoundedTheme,115	RmrkNftChild,116	CollectionPermissions,117	SchemaVersion,118};119120pub use pallet::*;121use sp_core::H160;122use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};123#[cfg(feature = "runtime-benchmarks")]124pub mod benchmarking;125pub mod dispatch;126pub mod erc;127pub mod eth;128pub mod weights;129130/// Weight info.131pub type SelfWeightOf<T> = <T as Config>::WeightInfo;132133/// Collection handle contains information about collection data and id.134/// Also provides functionality to count consumed gas.135/// CollectionHandle is used as a generic wrapper for collections of all types.136/// It allows to perform common operations and queries on any collection type,137/// both completely general for all, as well as their respective implementations of [CommonCollectionOperations].138#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]139pub struct CollectionHandle<T: Config> {140	/// Collection id141	pub id: CollectionId,142	collection: Collection<T::AccountId>,143	/// Substrate recorder for counting consumed gas144	pub recorder: SubstrateRecorder<T>,145}146147impl<T: Config> WithRecorder<T> for CollectionHandle<T> {148	fn recorder(&self) -> &SubstrateRecorder<T> {149		&self.recorder150	}151	fn into_recorder(self) -> SubstrateRecorder<T> {152		self.recorder153	}154}155156impl<T: Config> CollectionHandle<T> {157	/// Same as [CollectionHandle::new] but with an explicit gas limit.158	pub fn new_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {159		<CollectionById<T>>::get(id).map(|collection| Self {160			id,161			collection,162			recorder: SubstrateRecorder::new(gas_limit),163		})164	}165166	/// Same as [CollectionHandle::new] but with an existed [SubstrateRecorder].167	pub fn new_with_recorder(id: CollectionId, recorder: SubstrateRecorder<T>) -> Option<Self> {168		<CollectionById<T>>::get(id).map(|collection| Self {169			id,170			collection,171			recorder,172		})173	}174175	/// Retrives collection data from storage and creates collection handle with default parameters.176	/// If collection not found return `None`177	pub fn new(id: CollectionId) -> Option<Self> {178		Self::new_with_gas_limit(id, u64::MAX)179	}180181	/// Same as [CollectionHandle::new] but if collection not found [Error::CollectionNotFound] returned.182	pub fn try_get(id: CollectionId) -> Result<Self, DispatchError> {183		Ok(Self::new(id).ok_or(<Error<T>>::CollectionNotFound)?)184	}185186	/// Consume gas for reading.187	pub fn consume_store_reads(&self, reads: u64) -> evm_coder::execution::Result<()> {188		self.recorder189			.consume_gas(T::GasWeightMapping::weight_to_gas(190				<T as frame_system::Config>::DbWeight::get()191					.read192					.saturating_mul(reads),193			))194	}195196	/// Consume gas for writing.197	pub fn consume_store_writes(&self, writes: u64) -> evm_coder::execution::Result<()> {198		self.recorder199			.consume_gas(T::GasWeightMapping::weight_to_gas(200				<T as frame_system::Config>::DbWeight::get()201					.write202					.saturating_mul(writes),203			))204	}205206	/// Save collection to storage.207	pub fn save(self) -> DispatchResult {208		<CollectionById<T>>::insert(self.id, self.collection);209		Ok(())210	}211212	/// Set collection sponsor.213	///214	/// Unique collections allows sponsoring for certain actions.215	/// This method allows you to set the sponsor of the collection.216	/// In order for sponsorship to become active, it must be confirmed through [Self::confirm_sponsorship].217	pub fn set_sponsor(&mut self, sponsor: T::AccountId) -> DispatchResult {218		self.collection.sponsorship = SponsorshipState::Unconfirmed(sponsor);219		Ok(())220	}221222	/// Confirm sponsorship223	///224	/// In order for the sponsorship to become active, the user set as the sponsor must confirm their participation.225	/// Before confirming sponsorship, the user must be specified as the sponsor of the collection via [Self::set_sponsor].226	pub fn confirm_sponsorship(&mut self, sender: &T::AccountId) -> Result<bool, DispatchError> {227		if self.collection.sponsorship.pending_sponsor() != Some(sender) {228			return Ok(false);229		}230231		self.collection.sponsorship = SponsorshipState::Confirmed(sender.clone());232		Ok(true)233	}234235	/// Checks that the collection was created with, and must be operated upon through **Unique API**.236	/// Now check only the `external_collection` flag and if it's **true**, then return [Error::CollectionIsExternal] error.237	pub fn check_is_internal(&self) -> DispatchResult {238		if self.external_collection {239			return Err(<Error<T>>::CollectionIsExternal)?;240		}241242		Ok(())243	}244245	/// Checks that the collection was created with, and must be operated upon through an **assimilated API**.246	/// Now check only the `external_collection` flag and if it's **false**, then return [Error::CollectionIsInternal] error.247	pub fn check_is_external(&self) -> DispatchResult {248		if !self.external_collection {249			return Err(<Error<T>>::CollectionIsInternal)?;250		}251252		Ok(())253	}254}255256impl<T: Config> Deref for CollectionHandle<T> {257	type Target = Collection<T::AccountId>;258259	fn deref(&self) -> &Self::Target {260		&self.collection261	}262}263264impl<T: Config> DerefMut for CollectionHandle<T> {265	fn deref_mut(&mut self) -> &mut Self::Target {266		&mut self.collection267	}268}269270impl<T: Config> CollectionHandle<T> {271	/// Checks if the `user` is the owner of the collection.272	pub fn check_is_owner(&self, user: &T::CrossAccountId) -> DispatchResult {273		ensure!(*user.as_sub() == self.owner, <Error<T>>::NoPermission);274		Ok(())275	}276277	/// Returns **true** if the `user` is the owner or administrator of the collection.278	pub fn is_owner_or_admin(&self, user: &T::CrossAccountId) -> bool {279		*user.as_sub() == self.owner || <IsAdmin<T>>::get((self.id, user))280	}281282	/// Checks if the `user` is the owner or administrator of the collection.283	pub fn check_is_owner_or_admin(&self, user: &T::CrossAccountId) -> DispatchResult {284		ensure!(self.is_owner_or_admin(user), <Error<T>>::NoPermission);285		Ok(())286	}287288	/// Return **true** if `user` was not allowed to have tokens, and he can ignore such restrictions.289	pub fn ignores_allowance(&self, user: &T::CrossAccountId) -> bool {290		self.limits.owner_can_transfer() && self.is_owner_or_admin(user)291	}292293	/// Return **true** if `user` does not have enough token parts, and he can ignore such restrictions.294	pub fn ignores_owned_amount(&self, user: &T::CrossAccountId) -> bool {295		self.limits.owner_can_transfer() && self.is_owner_or_admin(user)296	}297298	/// Checks if the user is in the allow list. If not [Error::AddressNotInAllowlist] returns.299	pub fn check_allowlist(&self, user: &T::CrossAccountId) -> DispatchResult {300		ensure!(301			<Allowlist<T>>::get((self.id, user)),302			<Error<T>>::AddressNotInAllowlist303		);304		Ok(())305	}306}307308#[frame_support::pallet]309pub mod pallet {310	use super::*;311	use pallet_evm::account;312	use dispatch::CollectionDispatch;313	use frame_support::{Blake2_128Concat, pallet_prelude::*, storage::Key, traits::StorageVersion};314	use frame_system::pallet_prelude::*;315	use frame_support::traits::Currency;316	use up_data_structs::{TokenId, mapping::TokenAddressMapping};317	use scale_info::TypeInfo;318	use weights::WeightInfo;319320	#[pallet::config]321	pub trait Config:322		frame_system::Config323		+ pallet_evm_coder_substrate::Config324		+ pallet_evm::Config325		+ TypeInfo326		+ account::Config327	{328		/// Weight info.329		type WeightInfo: WeightInfo;330331		/// Events compatible with [frame_system::Config::Event].332		type Event: IsType<<Self as frame_system::Config>::Event> + From<Event<Self>>;333334		/// Currency.335		type Currency: Currency<Self::AccountId>;336337		/// Price getter to create the collection.338		#[pallet::constant]339		type CollectionCreationPrice: Get<340			<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,341		>;342343		/// Collection dispatcher.344		type CollectionDispatch: CollectionDispatch<Self>;345346		/// Treasury account id getter.347		type TreasuryAccountId: Get<Self::AccountId>;348349		/// Contract address getter.350		type ContractAddress: Get<H160>;351352		/// Mapper for tokens to Etherium addresses.353		type EvmTokenAddressMapping: TokenAddressMapping<H160>;354355		/// Mapper for tokens to [CrossAccountId].356		type CrossTokenAddressMapping: TokenAddressMapping<Self::CrossAccountId>;357	}358359	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);360361	#[pallet::pallet]362	#[pallet::storage_version(STORAGE_VERSION)]363	#[pallet::generate_store(pub(super) trait Store)]364	pub struct Pallet<T>(_);365366	#[pallet::extra_constants]367	impl<T: Config> Pallet<T> {368		/// Maximum admins per collection.369		pub fn collection_admins_limit() -> u32 {370			COLLECTION_ADMINS_LIMIT371		}372	}373374	#[pallet::event]375	#[pallet::generate_deposit(pub fn deposit_event)]376	pub enum Event<T: Config> {377		/// New collection was created378		CollectionCreated(379			/// Globally unique identifier of newly created collection.380			CollectionId,381			/// [CollectionMode] converted into _u8_.382			u8,383			/// Collection owner.384			T::AccountId,385		),386387		/// New collection was destroyed388		CollectionDestroyed(389			/// Globally unique identifier of collection.390			CollectionId,391		),392393		/// New item was created.394		ItemCreated(395			/// Id of the collection where item was created.396			CollectionId,397			/// Id of an item. Unique within the collection.398			TokenId,399			/// Owner of newly created item400			T::CrossAccountId,401			/// Always 1 for NFT402			u128,403		),404405		/// Collection item was burned.406		ItemDestroyed(407			/// Id of the collection where item was destroyed.408			CollectionId,409			/// Identifier of burned NFT.410			TokenId,411			/// Which user has destroyed its tokens.412			T::CrossAccountId,413			/// Amount of token pieces destroed. Always 1 for NFT.414			u128,415		),416417		/// Item was transferred418		Transfer(419			/// Id of collection to which item is belong.420			CollectionId,421			/// Id of an item.422			TokenId,423			/// Original owner of item.424			T::CrossAccountId,425			/// New owner of item.426			T::CrossAccountId,427			/// Amount of token pieces transfered. Always 1 for NFT.428			u128,429		),430431		/// Amount pieces of token owned by `sender` was approved for `spender`.432		Approved(433			/// Id of collection to which item is belong.434			CollectionId,435			/// Id of an item.436			TokenId,437			/// Original owner of item.438			T::CrossAccountId,439			/// Id for which the approval was granted.440			T::CrossAccountId,441			/// Amount of token pieces transfered. Always 1 for NFT.442			u128,443		),444445		/// The colletion property has been set.446		CollectionPropertySet(447			/// Id of collection to which property has been set.448			CollectionId,449			/// The property that was set.450			PropertyKey,451		),452453		/// The property has been deleted.454		CollectionPropertyDeleted(455			/// Id of collection to which property has been deleted.456			CollectionId,457			/// The property that was deleted.458			PropertyKey,459		),460461		/// The token property has been set.462		TokenPropertySet(463			/// Identifier of the collection whose token has the property set.464			CollectionId,465			/// The token for which the property was set.466			TokenId,467			/// The property that was set.468			PropertyKey,469		),470471		/// The token property has been deleted.472		TokenPropertyDeleted(473			/// Identifier of the collection whose token has the property deleted.474			CollectionId,475			/// The token for which the property was deleted.476			TokenId,477			/// The property that was deleted.478			PropertyKey,479		),480481		/// The colletion property permission has been set.482		PropertyPermissionSet(483			/// Id of collection to which property permission has been set.484			CollectionId,485			/// The property permission that was set.486			PropertyKey,487		),488	}489490	#[pallet::error]491	pub enum Error<T> {492		/// This collection does not exist.493		CollectionNotFound,494		/// Sender parameter and item owner must be equal.495		MustBeTokenOwner,496		/// No permission to perform action497		NoPermission,498		/// Destroying only empty collections is allowed499		CantDestroyNotEmptyCollection,500		/// Collection is not in mint mode.501		PublicMintingNotAllowed,502		/// Address is not in allow list.503		AddressNotInAllowlist,504505		/// Collection name can not be longer than 63 char.506		CollectionNameLimitExceeded,507		/// Collection description can not be longer than 255 char.508		CollectionDescriptionLimitExceeded,509		/// Token prefix can not be longer than 15 char.510		CollectionTokenPrefixLimitExceeded,511		/// Total collections bound exceeded.512		TotalCollectionsLimitExceeded,513		/// Exceeded max admin count514		CollectionAdminCountExceeded,515		/// Collection limit bounds per collection exceeded516		CollectionLimitBoundsExceeded,517		/// Tried to enable permissions which are only permitted to be disabled518		OwnerPermissionsCantBeReverted,519		/// Collection settings not allowing items transferring520		TransferNotAllowed,521		/// Account token limit exceeded per collection522		AccountTokenLimitExceeded,523		/// Collection token limit exceeded524		CollectionTokenLimitExceeded,525		/// Metadata flag frozen526		MetadataFlagFrozen,527528		/// Item not exists.529		TokenNotFound,530		/// Item balance not enough.531		TokenValueTooLow,532		/// Requested value more than approved.533		ApprovedValueTooLow,534		/// Tried to approve more than owned535		CantApproveMoreThanOwned,536537		/// Can't transfer tokens to ethereum zero address538		AddressIsZero,539		/// Target collection doesn't supports this operation540		UnsupportedOperation,541542		/// Not sufficient funds to perform action543		NotSufficientFounds,544545		/// User not passed nesting rule546		UserIsNotAllowedToNest,547		/// Only tokens from specific collections may nest tokens under this548		SourceCollectionIsNotAllowedToNest,549550		/// Tried to store more data than allowed in collection field551		CollectionFieldSizeExceeded,552553		/// Tried to store more property data than allowed554		NoSpaceForProperty,555556		/// Tried to store more property keys than allowed557		PropertyLimitReached,558559		/// Property key is too long560		PropertyKeyIsTooLong,561562		/// Only ASCII letters, digits, and '_', '-' are allowed563		InvalidCharacterInPropertyKey,564565		/// Empty property keys are forbidden566		EmptyPropertyKey,567568		/// Tried to access an external collection with an internal API569		CollectionIsExternal,570571		/// Tried to access an internal collection with an external API572		CollectionIsInternal,573	}574575	/// Storage of the count of created collections.576	#[pallet::storage]577	pub type CreatedCollectionCount<T> = StorageValue<Value = CollectionId, QueryKind = ValueQuery>;578579	/// Storage of the count of deleted collections.580	#[pallet::storage]581	pub type DestroyedCollectionCount<T> =582		StorageValue<Value = CollectionId, QueryKind = ValueQuery>;583584	/// Storage of collection info.585	#[pallet::storage]586	pub type CollectionById<T> = StorageMap<587		Hasher = Blake2_128Concat,588		Key = CollectionId,589		Value = Collection<<T as frame_system::Config>::AccountId>,590		QueryKind = OptionQuery,591	>;592593	/// Storage of collection properties.594	#[pallet::storage]595	#[pallet::getter(fn collection_properties)]596	pub type CollectionProperties<T> = StorageMap<597		Hasher = Blake2_128Concat,598		Key = CollectionId,599		Value = Properties,600		QueryKind = ValueQuery,601		OnEmpty = up_data_structs::CollectionProperties,602	>;603604	/// Storage of collection properties permissions.605	#[pallet::storage]606	#[pallet::getter(fn property_permissions)]607	pub type CollectionPropertyPermissions<T> = StorageMap<608		Hasher = Blake2_128Concat,609		Key = CollectionId,610		Value = PropertiesPermissionMap,611		QueryKind = ValueQuery,612	>;613614	/// Storage of collection admins count.615	#[pallet::storage]616	pub type AdminAmount<T> = StorageMap<617		Hasher = Blake2_128Concat,618		Key = CollectionId,619		Value = u32,620		QueryKind = ValueQuery,621	>;622623	/// List of collection admins624	#[pallet::storage]625	pub type IsAdmin<T: Config> = StorageNMap<626		Key = (627			Key<Blake2_128Concat, CollectionId>,628			Key<Blake2_128Concat, T::CrossAccountId>,629		),630		Value = bool,631		QueryKind = ValueQuery,632	>;633634	/// Allowlisted collection users635	#[pallet::storage]636	pub type Allowlist<T: Config> = StorageNMap<637		Key = (638			Key<Blake2_128Concat, CollectionId>,639			Key<Blake2_128Concat, T::CrossAccountId>,640		),641		Value = bool,642		QueryKind = ValueQuery,643	>;644645	/// Not used by code, exists only to provide some types to metadata.646	#[pallet::storage]647	pub type DummyStorageValue<T: Config> = StorageValue<648		Value = (649			CollectionStats,650			CollectionId,651			TokenId,652			TokenChild,653			PhantomType<(654				TokenData<T::CrossAccountId>,655				RpcCollection<T::AccountId>,656				// RMRK657				RmrkCollectionInfo<T::AccountId>,658				RmrkInstanceInfo<T::AccountId>,659				RmrkResourceInfo,660				RmrkPropertyInfo,661				RmrkBaseInfo<T::AccountId>,662				RmrkPartType,663				RmrkBoundedTheme,664				RmrkNftChild,665			)>,666		),667		QueryKind = OptionQuery,668	>;669670	#[pallet::hooks]671	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {672		fn on_runtime_upgrade() -> Weight {673			if StorageVersion::get::<Pallet<T>>() < StorageVersion::new(1) {674				use up_data_structs::{CollectionVersion1, CollectionVersion2};675				<CollectionById<T>>::translate::<CollectionVersion1<T::AccountId>, _>(|id, v| {676					let mut props = Vec::new();677					if !v.offchain_schema.is_empty() {678						props.push(Property {679							key: b"_old_offchainSchema".to_vec().try_into().unwrap(),680							value: v681								.offchain_schema682								.clone()683								.into_inner()684								.try_into()685								.expect("offchain schema too big"),686						});687					}688					if !v.variable_on_chain_schema.is_empty() {689						props.push(Property {690							key: b"_old_variableOnChainSchema".to_vec().try_into().unwrap(),691							value: v692								.variable_on_chain_schema693								.clone()694								.into_inner()695								.try_into()696								.expect("offchain schema too big"),697						});698					}699					if !v.const_on_chain_schema.is_empty() {700						props.push(Property {701							key: b"_old_constOnChainSchema".to_vec().try_into().unwrap(),702							value: v703								.const_on_chain_schema704								.clone()705								.into_inner()706								.try_into()707								.expect("offchain schema too big"),708						});709					}710					props.push(Property {711						key: b"_old_schemaVersion".to_vec().try_into().unwrap(),712						value: match v.schema_version {713							SchemaVersion::ImageURL => b"ImageUrl".as_slice(),714							SchemaVersion::Unique => b"Unique".as_slice(),715						}716						.to_vec()717						.try_into()718						.unwrap(),719					});720					Self::set_scoped_collection_properties(721						id,722						PropertyScope::None,723						props.into_iter(),724					)725					.expect("existing data larger than properties");726					let mut new = CollectionVersion2::from(v.clone());727					new.permissions.access = Some(v.access);728					new.permissions.mint_mode = Some(v.mint_mode);729					Some(new)730				});731			}732733			0734		}735	}736}737738impl<T: Config> Pallet<T> {739	/// Enshure that receiver address is correct.740	///741	/// Ethereum receiver 0x0000000000000000000000000000000000000000 is reserved, and shouldn't own tokens.742	pub fn ensure_correct_receiver(receiver: &T::CrossAccountId) -> DispatchResult {743		ensure!(744			&T::CrossAccountId::from_eth(H160([0; 20])) != receiver,745			<Error<T>>::AddressIsZero746		);747		Ok(())748	}749750	/// Get a vector of collection admins.751	pub fn adminlist(collection: CollectionId) -> Vec<T::CrossAccountId> {752		<IsAdmin<T>>::iter_prefix((collection,))753			.map(|(a, _)| a)754			.collect()755	}756757	/// Get a vector of users allowed to mint tokens.758	pub fn allowlist(collection: CollectionId) -> Vec<T::CrossAccountId> {759		<Allowlist<T>>::iter_prefix((collection,))760			.map(|(a, _)| a)761			.collect()762	}763764	/// Is `user` allowed to mint token in `collection`.765	pub fn allowed(collection: CollectionId, user: T::CrossAccountId) -> bool {766		<Allowlist<T>>::get((collection, user))767	}768769	/// Get statistics of collections.770	pub fn collection_stats() -> CollectionStats {771		let created = <CreatedCollectionCount<T>>::get();772		let destroyed = <DestroyedCollectionCount<T>>::get();773		CollectionStats {774			created: created.0,775			destroyed: destroyed.0,776			alive: created.0 - destroyed.0,777		}778	}779780	/// Get the effective limits for the collection.781	pub fn effective_collection_limits(collection: CollectionId) -> Option<CollectionLimits> {782		let collection = <CollectionById<T>>::get(collection);783		if collection.is_none() {784			return None;785		}786787		let collection = collection.unwrap();788		let limits = collection.limits;789		let effective_limits = CollectionLimits {790			account_token_ownership_limit: Some(limits.account_token_ownership_limit()),791			sponsored_data_size: Some(limits.sponsored_data_size()),792			sponsored_data_rate_limit: Some(793				limits794					.sponsored_data_rate_limit795					.unwrap_or(SponsoringRateLimit::SponsoringDisabled),796			),797			token_limit: Some(limits.token_limit()),798			sponsor_transfer_timeout: Some(limits.sponsor_transfer_timeout(799				match collection.mode {800					CollectionMode::NFT => NFT_SPONSOR_TRANSFER_TIMEOUT,801					CollectionMode::Fungible(_) => FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,802					CollectionMode::ReFungible => REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,803				},804			)),805			sponsor_approve_timeout: Some(limits.sponsor_approve_timeout()),806			owner_can_transfer: Some(limits.owner_can_transfer()),807			owner_can_destroy: Some(limits.owner_can_destroy()),808			transfers_enabled: Some(limits.transfers_enabled()),809		};810811		Some(effective_limits)812	}813814	/// Returns information about the `collection` adapted for rpc.815	pub fn rpc_collection(collection: CollectionId) -> Option<RpcCollection<T::AccountId>> {816		let Collection {817			name,818			description,819			owner,820			mode,821			token_prefix,822			sponsorship,823			limits,824			permissions,825			external_collection,826		} = <CollectionById<T>>::get(collection)?;827828		let token_property_permissions = <CollectionPropertyPermissions<T>>::get(collection)829			.into_iter()830			.map(|(key, permission)| PropertyKeyPermission { key, permission })831			.collect();832833		let properties = <CollectionProperties<T>>::get(collection)834			.into_iter()835			.map(|(key, value)| Property { key, value })836			.collect();837838		let permissions = CollectionPermissions {839			access: Some(permissions.access()),840			mint_mode: Some(permissions.mint_mode()),841			nesting: Some(permissions.nesting().clone()),842		};843844		Some(RpcCollection {845			name: name.into_inner(),846			description: description.into_inner(),847			owner,848			mode,849			token_prefix: token_prefix.into_inner(),850			sponsorship,851			limits,852			permissions,853			token_property_permissions,854			properties,855			read_only: external_collection,856		})857	}858}859860macro_rules! limit_default {861	($old:ident, $new:ident, $($field:ident $(($arg:expr))? => $check:expr),* $(,)?) => {{862		$(863			if let Some($new) = $new.$field {864				let $old = $old.$field($($arg)?);865				let _ = $new;866				let _ = $old;867				$check868			} else {869				$new.$field = $old.$field870			}871		)*872	}};873}874macro_rules! limit_default_clone {875	($old:ident, $new:ident, $($field:ident $(($arg:expr))? => $check:expr),* $(,)?) => {{876		$(877			if let Some($new) = $new.$field.clone() {878				let $old = $old.$field($($arg)?);879				let _ = $new;880				let _ = $old;881				$check882			} else {883				$new.$field = $old.$field.clone()884			}885		)*886	}};887}888889impl<T: Config> Pallet<T> {890	/// Create new collection.891	///892	/// * `owner` - The owner of the collection.893	/// * `data` - Description of the created collection.894	/// * `is_external` - Marks that collection managet by not "Unique network".895	pub fn init_collection(896		owner: T::CrossAccountId,897		data: CreateCollectionData<T::AccountId>,898		is_external: bool,899	) -> Result<CollectionId, DispatchError> {900		{901			ensure!(902				data.token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH as usize,903				Error::<T>::CollectionTokenPrefixLimitExceeded904			);905		}906907		let created_count = <CreatedCollectionCount<T>>::get()908			.0909			.checked_add(1)910			.ok_or(ArithmeticError::Overflow)?;911		let destroyed_count = <DestroyedCollectionCount<T>>::get().0;912		let id = CollectionId(created_count);913914		// bound Total number of collections915		ensure!(916			created_count - destroyed_count <= COLLECTION_NUMBER_LIMIT,917			<Error<T>>::TotalCollectionsLimitExceeded918		);919920		// =========921922		let collection = Collection {923			owner: owner.as_sub().clone(),924			name: data.name,925			mode: data.mode.clone(),926			description: data.description,927			token_prefix: data.token_prefix,928			sponsorship: data929				.pending_sponsor930				.map(SponsorshipState::Unconfirmed)931				.unwrap_or_default(),932			limits: data933				.limits934				.map(|limits| Self::clamp_limits(data.mode.clone(), &Default::default(), limits))935				.unwrap_or_else(|| Ok(CollectionLimits::default()))?,936			permissions: data937				.permissions938				.map(|permissions| {939					Self::clamp_permissions(data.mode.clone(), &Default::default(), permissions)940				})941				.unwrap_or_else(|| Ok(CollectionPermissions::default()))?,942			external_collection: is_external,943		};944945		let mut collection_properties = up_data_structs::CollectionProperties::get();946		collection_properties947			.try_set_from_iter(data.properties.into_iter())948			.map_err(<Error<T>>::from)?;949950		CollectionProperties::<T>::insert(id, collection_properties);951952		let mut token_props_permissions = PropertiesPermissionMap::new();953		token_props_permissions954			.try_set_from_iter(data.token_property_permissions.into_iter())955			.map_err(<Error<T>>::from)?;956957		CollectionPropertyPermissions::<T>::insert(id, token_props_permissions);958959		// Take a (non-refundable) deposit of collection creation960		{961			let mut imbalance =962				<<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();963			imbalance.subsume(964				<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(965					&T::TreasuryAccountId::get(),966					T::CollectionCreationPrice::get(),967				),968			);969			<T as Config>::Currency::settle(970				&owner.as_sub(),971				imbalance,972				WithdrawReasons::TRANSFER,973				ExistenceRequirement::KeepAlive,974			)975			.map_err(|_| Error::<T>::NotSufficientFounds)?;976		}977978		<CreatedCollectionCount<T>>::put(created_count);979		<Pallet<T>>::deposit_event(Event::CollectionCreated(980			id,981			data.mode.id(),982			owner.as_sub().clone(),983		));984		<PalletEvm<T>>::deposit_log(985			erc::CollectionHelpersEvents::CollectionCreated {986				owner: *owner.as_eth(),987				collection_id: eth::collection_id_to_address(id),988			}989			.to_log(T::ContractAddress::get()),990		);991		<CollectionById<T>>::insert(id, collection);992		Ok(id)993	}994995	/// Destroy collection.996	///997	/// * `collection` - Collection handler.998	/// * `sender` - The owner or administrator of the collection.999	pub fn destroy_collection(1000		collection: CollectionHandle<T>,1001		sender: &T::CrossAccountId,1002	) -> DispatchResult {1003		ensure!(1004			collection.limits.owner_can_destroy(),1005			<Error<T>>::NoPermission,1006		);1007		collection.check_is_owner(sender)?;10081009		let destroyed_collections = <DestroyedCollectionCount<T>>::get()1010			.01011			.checked_add(1)1012			.ok_or(ArithmeticError::Overflow)?;10131014		// =========10151016		<DestroyedCollectionCount<T>>::put(destroyed_collections);1017		<CollectionById<T>>::remove(collection.id);1018		<AdminAmount<T>>::remove(collection.id);1019		<IsAdmin<T>>::remove_prefix((collection.id,), None);1020		<Allowlist<T>>::remove_prefix((collection.id,), None);1021		<CollectionProperties<T>>::remove(collection.id);10221023		<Pallet<T>>::deposit_event(Event::CollectionDestroyed(collection.id));1024		Ok(())1025	}10261027	/// Set collection property.1028	///1029	/// * `collection` - Collection handler.1030	/// * `sender` - The owner or administrator of the collection.1031	/// * `property` - The property to set.1032	pub fn set_collection_property(1033		collection: &CollectionHandle<T>,1034		sender: &T::CrossAccountId,1035		property: Property,1036	) -> DispatchResult {1037		collection.check_is_owner_or_admin(sender)?;10381039		CollectionProperties::<T>::try_mutate(collection.id, |properties| {1040			let property = property.clone();1041			properties.try_set(property.key, property.value)1042		})1043		.map_err(<Error<T>>::from)?;10441045		Self::deposit_event(Event::CollectionPropertySet(collection.id, property.key));10461047		Ok(())1048	}10491050	/// Set scouped collection property.1051	///1052	/// * `collection_id` - ID of the collection for which the property is being set.1053	/// * `scope` - Property scope.1054	/// * `property` - The property to set.1055	pub fn set_scoped_collection_property(1056		collection_id: CollectionId,1057		scope: PropertyScope,1058		property: Property,1059	) -> DispatchResult {1060		CollectionProperties::<T>::try_mutate(collection_id, |properties| {1061			properties.try_scoped_set(scope, property.key, property.value)1062		})1063		.map_err(<Error<T>>::from)?;10641065		Ok(())1066	}10671068	/// Set scouped collection properties.1069	///1070	/// * `collection_id` - ID of the collection for which the properties is being set.1071	/// * `scope` - Property scope.1072	/// * `properties` - The properties to set.1073	pub fn set_scoped_collection_properties(1074		collection_id: CollectionId,1075		scope: PropertyScope,1076		properties: impl Iterator<Item = Property>,1077	) -> DispatchResult {1078		CollectionProperties::<T>::try_mutate(collection_id, |stored_properties| {1079			stored_properties.try_scoped_set_from_iter(scope, properties)1080		})1081		.map_err(<Error<T>>::from)?;10821083		Ok(())1084	}10851086	/// Set collection properties.1087	///1088	/// * `collection` - Collection handler.1089	/// * `sender` - The owner or administrator of the collection.1090	/// * `properties` - The properties to set.1091	#[transactional]1092	pub fn set_collection_properties(1093		collection: &CollectionHandle<T>,1094		sender: &T::CrossAccountId,1095		properties: Vec<Property>,1096	) -> DispatchResult {1097		for property in properties {1098			Self::set_collection_property(collection, sender, property)?;1099		}11001101		Ok(())1102	}11031104	/// Delete collection property.1105	///1106	/// * `collection` - Collection handler.1107	/// * `sender` - The owner or administrator of the collection.1108	/// * `property` - The property to delete.1109	pub fn delete_collection_property(1110		collection: &CollectionHandle<T>,1111		sender: &T::CrossAccountId,1112		property_key: PropertyKey,1113	) -> DispatchResult {1114		collection.check_is_owner_or_admin(sender)?;11151116		CollectionProperties::<T>::try_mutate(collection.id, |properties| {1117			properties.remove(&property_key)1118		})1119		.map_err(<Error<T>>::from)?;11201121		Self::deposit_event(Event::CollectionPropertyDeleted(1122			collection.id,1123			property_key,1124		));11251126		Ok(())1127	}11281129	/// Delete collection properties.1130	///1131	/// * `collection` - Collection handler.1132	/// * `sender` - The owner or administrator of the collection.1133	/// * `properties` - The properties to delete.1134	#[transactional]1135	pub fn delete_collection_properties(1136		collection: &CollectionHandle<T>,1137		sender: &T::CrossAccountId,1138		property_keys: Vec<PropertyKey>,1139	) -> DispatchResult {1140		for key in property_keys {1141			Self::delete_collection_property(collection, sender, key)?;1142		}11431144		Ok(())1145	}11461147	/// Set collection propetry permission without any checks.1148	///1149	/// Used for migrations.1150	///1151	/// * `collection` - Collection handler.1152	/// * `property_permissions` - Property permissions.1153	pub fn set_property_permission_unchecked(1154		collection: CollectionId,1155		property_permission: PropertyKeyPermission,1156	) -> DispatchResult {1157		<CollectionPropertyPermissions<T>>::try_mutate(collection, |permissions| {1158			permissions.try_set(property_permission.key, property_permission.permission)1159		})1160		.map_err(<Error<T>>::from)?;1161		Ok(())1162	}11631164	/// Set collection property permission.1165	///1166	/// * `collection` - Collection handler.1167	/// * `sender` - The owner or administrator of the collection.1168	/// * `property_permission` - Property permission.1169	pub fn set_property_permission(1170		collection: &CollectionHandle<T>,1171		sender: &T::CrossAccountId,1172		property_permission: PropertyKeyPermission,1173	) -> DispatchResult {1174		collection.check_is_owner_or_admin(sender)?;11751176		let all_permissions = CollectionPropertyPermissions::<T>::get(collection.id);1177		let current_permission = all_permissions.get(&property_permission.key);1178		if matches![1179			current_permission,1180			Some(PropertyPermission { mutable: false, .. })1181		] {1182			return Err(<Error<T>>::NoPermission.into());1183		}11841185		CollectionPropertyPermissions::<T>::try_mutate(collection.id, |permissions| {1186			let property_permission = property_permission.clone();1187			permissions.try_set(property_permission.key, property_permission.permission)1188		})1189		.map_err(<Error<T>>::from)?;11901191		Self::deposit_event(Event::PropertyPermissionSet(1192			collection.id,1193			property_permission.key,1194		));11951196		Ok(())1197	}11981199	/// Set token property permission.1200	///1201	/// * `collection` - Collection handler.1202	/// * `sender` - The owner or administrator of the collection.1203	/// * `property_permissions` - Property permissions.1204	#[transactional]1205	pub fn set_token_property_permissions(1206		collection: &CollectionHandle<T>,1207		sender: &T::CrossAccountId,1208		property_permissions: Vec<PropertyKeyPermission>,1209	) -> DispatchResult {1210		for prop_pemission in property_permissions {1211			Self::set_property_permission(collection, sender, prop_pemission)?;1212		}12131214		Ok(())1215	}12161217	/// Get collection property.1218	pub fn get_collection_property(1219		collection_id: CollectionId,1220		key: &PropertyKey,1221	) -> Option<PropertyValue> {1222		Self::collection_properties(collection_id).get(key).cloned()1223	}12241225	/// Convert byte vector to property key vector.1226	pub fn bytes_keys_to_property_keys(1227		keys: Vec<Vec<u8>>,1228	) -> Result<Vec<PropertyKey>, DispatchError> {1229		keys.into_iter()1230			.map(|key| -> Result<PropertyKey, DispatchError> {1231				key.try_into()1232					.map_err(|_| <Error<T>>::PropertyKeyIsTooLong.into())1233			})1234			.collect::<Result<Vec<PropertyKey>, DispatchError>>()1235	}12361237	/// Get properties according to given keys.1238	pub fn filter_collection_properties(1239		collection_id: CollectionId,1240		keys: Option<Vec<PropertyKey>>,1241	) -> Result<Vec<Property>, DispatchError> {1242		let properties = Self::collection_properties(collection_id);12431244		let properties = keys1245			.map(|keys| {1246				keys.into_iter()1247					.filter_map(|key| {1248						properties.get(&key).map(|value| Property {1249							key,1250							value: value.clone(),1251						})1252					})1253					.collect()1254			})1255			.unwrap_or_else(|| {1256				properties1257					.into_iter()1258					.map(|(key, value)| Property { key, value })1259					.collect()1260			});12611262		Ok(properties)1263	}12641265	/// Get property permissions according to given keys.1266	pub fn filter_property_permissions(1267		collection_id: CollectionId,1268		keys: Option<Vec<PropertyKey>>,1269	) -> Result<Vec<PropertyKeyPermission>, DispatchError> {1270		let permissions = Self::property_permissions(collection_id);12711272		let key_permissions = keys1273			.map(|keys| {1274				keys.into_iter()1275					.filter_map(|key| {1276						permissions1277							.get(&key)1278							.map(|permission| PropertyKeyPermission {1279								key,1280								permission: permission.clone(),1281							})1282					})1283					.collect()1284			})1285			.unwrap_or_else(|| {1286				permissions1287					.into_iter()1288					.map(|(key, permission)| PropertyKeyPermission { key, permission })1289					.collect()1290			});12911292		Ok(key_permissions)1293	}12941295	/// Toggle `user` participation in the `collection`'s allow list.1296	pub fn toggle_allowlist(1297		collection: &CollectionHandle<T>,1298		sender: &T::CrossAccountId,1299		user: &T::CrossAccountId,1300		allowed: bool,1301	) -> DispatchResult {1302		collection.check_is_owner_or_admin(sender)?;13031304		// =========13051306		if allowed {1307			<Allowlist<T>>::insert((collection.id, user), true);1308		} else {1309			<Allowlist<T>>::remove((collection.id, user));1310		}13111312		Ok(())1313	}13141315	/// Toggle `user` participation in the `collection`'s admin list.1316	pub fn toggle_admin(1317		collection: &CollectionHandle<T>,1318		sender: &T::CrossAccountId,1319		user: &T::CrossAccountId,1320		admin: bool,1321	) -> DispatchResult {1322		collection.check_is_owner(sender)?;13231324		let was_admin = <IsAdmin<T>>::get((collection.id, user));1325		if was_admin == admin {1326			return Ok(());1327		}1328		let amount = <AdminAmount<T>>::get(collection.id);13291330		if admin {1331			let amount = amount1332				.checked_add(1)1333				.ok_or(<Error<T>>::CollectionAdminCountExceeded)?;1334			ensure!(1335				amount <= Self::collection_admins_limit(),1336				<Error<T>>::CollectionAdminCountExceeded,1337			);13381339			// =========13401341			<AdminAmount<T>>::insert(collection.id, amount);1342			<IsAdmin<T>>::insert((collection.id, user), true);1343		} else {1344			<AdminAmount<T>>::insert(collection.id, amount.saturating_sub(1));1345			<IsAdmin<T>>::remove((collection.id, user));1346		}13471348		Ok(())1349	}13501351	/// Merge set fields from `new_limit` to `old_limit`.1352	pub fn clamp_limits(1353		mode: CollectionMode,1354		old_limit: &CollectionLimits,1355		mut new_limit: CollectionLimits,1356	) -> Result<CollectionLimits, DispatchError> {1357		let limits = old_limit;1358		limit_default!(old_limit, new_limit,1359			account_token_ownership_limit => ensure!(1360				new_limit <= MAX_TOKEN_OWNERSHIP,1361				<Error<T>>::CollectionLimitBoundsExceeded,1362			),1363			sponsored_data_size => ensure!(1364				new_limit <= CUSTOM_DATA_LIMIT,1365				<Error<T>>::CollectionLimitBoundsExceeded,1366			),13671368			sponsored_data_rate_limit => {},1369			token_limit => ensure!(1370				old_limit >= new_limit && new_limit > 0,1371				<Error<T>>::CollectionTokenLimitExceeded1372			),13731374			sponsor_transfer_timeout(match mode {1375				CollectionMode::NFT => NFT_SPONSOR_TRANSFER_TIMEOUT,1376				CollectionMode::Fungible(_) => FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,1377				CollectionMode::ReFungible => REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,1378			}) => ensure!(1379				new_limit <= MAX_SPONSOR_TIMEOUT,1380				<Error<T>>::CollectionLimitBoundsExceeded,1381			),1382			sponsor_approve_timeout => {},1383			owner_can_transfer => ensure!(1384				!limits.owner_can_transfer_instaled() ||1385				old_limit || !new_limit,1386				<Error<T>>::OwnerPermissionsCantBeReverted,1387			),1388			owner_can_destroy => ensure!(1389				old_limit || !new_limit,1390				<Error<T>>::OwnerPermissionsCantBeReverted,1391			),1392			transfers_enabled => {},1393		);1394		Ok(new_limit)1395	}13961397	/// Merge set fields from `new_permission` to `old_permission`.1398	pub fn clamp_permissions(1399		_mode: CollectionMode,1400		old_permission: &CollectionPermissions,1401		mut new_permission: CollectionPermissions,1402	) -> Result<CollectionPermissions, DispatchError> {1403		limit_default_clone!(old_permission, new_permission,1404			access => {},1405			mint_mode => {},1406			nesting => { /* todo check for permissive, if only it gets out of benchmarks */ },1407		);1408		Ok(new_permission)1409	}1410}14111412/// Indicates unsupported methods by returning [Error::UnsupportedOperation].1413#[macro_export]1414macro_rules! unsupported {1415	() => {1416		Err(<Error<T>>::UnsupportedOperation.into())1417	};1418}14191420/// Return weights for various worst-case operations.1421pub trait CommonWeightInfo<CrossAccountId> {1422	/// Weight of item creation.1423	fn create_item() -> Weight;14241425	/// Weight of items creation.1426	fn create_multiple_items(amount: &[CreateItemData]) -> Weight;14271428	/// Weight of items creation.1429	fn create_multiple_items_ex(cost: &CreateItemExData<CrossAccountId>) -> Weight;14301431	/// The weight of the burning item.1432	fn burn_item() -> Weight;14331434	/// Property setting weight.1435	///1436	/// * `amount`- The number of properties to set.1437	fn set_collection_properties(amount: u32) -> Weight;14381439	/// Collection property deletion weight.1440	///1441	/// * `amount`- The number of properties to set.1442	fn delete_collection_properties(amount: u32) -> Weight;14431444	/// Token property setting weight.1445	///1446	/// * `amount`- The number of properties to set.1447	fn set_token_properties(amount: u32) -> Weight;14481449	/// Token property deletion weight.1450	///1451	/// * `amount`- The number of properties to delete.1452	fn delete_token_properties(amount: u32) -> Weight;14531454	/// Token property permissions set weight.1455	///1456	/// * `amount`- The number of property permissions to set.1457	fn set_token_property_permissions(amount: u32) -> Weight;14581459	/// Transfer price of the token or its parts.1460	fn transfer() -> Weight;14611462	/// The price of setting the permission of the operation from another user.1463	fn approve() -> Weight;14641465	/// Transfer price from another user.1466	fn transfer_from() -> Weight;14671468	/// The price of burning a token from another user.1469	fn burn_from() -> Weight;14701471	/// Differs from burn_item in case of Fungible and Refungible, as it should burn1472	/// whole users's balance1473	///1474	/// This method shouldn't be used directly, as it doesn't count breadth price, use [burn_recursively](CommonWeightInfo::burn_recursively) instead1475	fn burn_recursively_self_raw() -> Weight;14761477	/// Cost of iterating over `amount` children while burning, without counting child burning itself1478	///1479	/// This method shouldn't be used directly, as it doesn't count depth price, use [burn_recursively](CommonWeightInfo::burn_recursively) instead1480	fn burn_recursively_breadth_raw(amount: u32) -> Weight;14811482	/// The price of recursive burning a token.1483	///1484	/// `max_selfs` -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 has access to the token.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 has access to the token.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 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 property to get.1760	/// * `keys` - Vector of 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}