git.delta.rocks / unique-network / refs/commits / 285030f49a3f

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 an interface for common collection operations for different collection types24//! (see [CommonCollectionOperations]), as well as a generic dispatcher for these, see [dispatch] module.25//! It also provides this functionality to EVM, see [erc] and [eth] modules.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 [CollectionNotFound](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	/// Remove collection sponsor.235	pub fn remove_sponsor(&mut self) -> DispatchResult {236		self.collection.sponsorship = SponsorshipState::Disabled;237		Ok(())238	}239240	/// Checks that the collection was created with, and must be operated upon through **Unique API**.241	/// Now check only the `external_collection` flag and if it's **true**, then return [`Error::CollectionIsExternal`] error.242	pub fn check_is_internal(&self) -> DispatchResult {243		if self.external_collection {244			return Err(<Error<T>>::CollectionIsExternal)?;245		}246247		Ok(())248	}249250	/// Checks that the collection was created with, and must be operated upon through an **assimilated API**.251	/// Now check only the `external_collection` flag and if it's **false**, then return [`Error::CollectionIsInternal`] error.252	pub fn check_is_external(&self) -> DispatchResult {253		if !self.external_collection {254			return Err(<Error<T>>::CollectionIsInternal)?;255		}256257		Ok(())258	}259}260261impl<T: Config> Deref for CollectionHandle<T> {262	type Target = Collection<T::AccountId>;263264	fn deref(&self) -> &Self::Target {265		&self.collection266	}267}268269impl<T: Config> DerefMut for CollectionHandle<T> {270	fn deref_mut(&mut self) -> &mut Self::Target {271		&mut self.collection272	}273}274275impl<T: Config> CollectionHandle<T> {276	/// Checks if the `user` is the owner of the collection.277	pub fn check_is_owner(&self, user: &T::CrossAccountId) -> DispatchResult {278		ensure!(*user.as_sub() == self.owner, <Error<T>>::NoPermission);279		Ok(())280	}281282	/// Returns **true** if the `user` is the owner or administrator of the collection.283	pub fn is_owner_or_admin(&self, user: &T::CrossAccountId) -> bool {284		*user.as_sub() == self.owner || <IsAdmin<T>>::get((self.id, user))285	}286287	/// Checks if the `user` is the owner or administrator of the collection.288	pub fn check_is_owner_or_admin(&self, user: &T::CrossAccountId) -> DispatchResult {289		ensure!(self.is_owner_or_admin(user), <Error<T>>::NoPermission);290		Ok(())291	}292293	/// Return **true** if `user` was not allowed to have tokens, and he can ignore such restrictions.294	pub fn ignores_allowance(&self, user: &T::CrossAccountId) -> bool {295		self.limits.owner_can_transfer() && self.is_owner_or_admin(user)296	}297298	/// Return **true** if `user` does not have enough token parts, and he can ignore such restrictions.299	pub fn ignores_owned_amount(&self, user: &T::CrossAccountId) -> bool {300		self.limits.owner_can_transfer() && self.is_owner_or_admin(user)301	}302303	/// Checks if the user is in the allow list. If not [Error::AddressNotInAllowlist] returns.304	pub fn check_allowlist(&self, user: &T::CrossAccountId) -> DispatchResult {305		ensure!(306			<Allowlist<T>>::get((self.id, user)),307			<Error<T>>::AddressNotInAllowlist308		);309		Ok(())310	}311312	/// Changes collection owner to another account313	fn set_owner_internal(314		&mut self,315		caller: T::CrossAccountId,316		new_owner: T::CrossAccountId,317	) -> DispatchResult {318		self.check_is_owner(&caller)?;319		self.collection.owner = new_owner.as_sub().clone();320		self.save()321	}322}323324#[frame_support::pallet]325pub mod pallet {326	use super::*;327	use pallet_evm::account;328	use dispatch::CollectionDispatch;329	use frame_support::{Blake2_128Concat, pallet_prelude::*, storage::Key, traits::StorageVersion};330	use frame_system::pallet_prelude::*;331	use frame_support::traits::Currency;332	use up_data_structs::{TokenId, mapping::TokenAddressMapping};333	use scale_info::TypeInfo;334	use weights::WeightInfo;335336	#[pallet::config]337	pub trait Config:338		frame_system::Config339		+ pallet_evm_coder_substrate::Config340		+ pallet_evm::Config341		+ TypeInfo342		+ account::Config343	{344		/// Weight information for functions of this pallet.345		type WeightInfo: WeightInfo;346347		/// Events compatible with [`frame_system::Config::Event`].348		type Event: IsType<<Self as frame_system::Config>::Event> + From<Event<Self>>;349350		/// Handler of accounts and payment.351		type Currency: Currency<Self::AccountId>;352353		/// Set price to create a collection.354		#[pallet::constant]355		type CollectionCreationPrice: Get<356			<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,357		>;358359		/// Dispatcher of operations on collections.360		type CollectionDispatch: CollectionDispatch<Self>;361362		/// Account which holds the chain's treasury.363		type TreasuryAccountId: Get<Self::AccountId>;364365		/// Address under which the CollectionHelper contract would be available.366		type ContractAddress: Get<H160>;367368		/// Mapper for token addresses to Ethereum addresses.369		type EvmTokenAddressMapping: TokenAddressMapping<H160>;370371		/// Mapper for token addresses to [`CrossAccountId`].372		type CrossTokenAddressMapping: TokenAddressMapping<Self::CrossAccountId>;373	}374375	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);376377	#[pallet::pallet]378	#[pallet::storage_version(STORAGE_VERSION)]379	#[pallet::generate_store(pub(super) trait Store)]380	pub struct Pallet<T>(_);381382	#[pallet::extra_constants]383	impl<T: Config> Pallet<T> {384		/// Maximum admins per collection.385		pub fn collection_admins_limit() -> u32 {386			COLLECTION_ADMINS_LIMIT387		}388	}389390	#[pallet::event]391	#[pallet::generate_deposit(pub fn deposit_event)]392	pub enum Event<T: Config> {393		/// New collection was created394		CollectionCreated(395			/// Globally unique identifier of newly created collection.396			CollectionId,397			/// [`CollectionMode`] converted into _u8_.398			u8,399			/// Collection owner.400			T::AccountId,401		),402403		/// New collection was destroyed404		CollectionDestroyed(405			/// Globally unique identifier of collection.406			CollectionId,407		),408409		/// New item was created.410		ItemCreated(411			/// Id of the collection where item was created.412			CollectionId,413			/// Id of an item. Unique within the collection.414			TokenId,415			/// Owner of newly created item416			T::CrossAccountId,417			/// Always 1 for NFT418			u128,419		),420421		/// Collection item was burned.422		ItemDestroyed(423			/// Id of the collection where item was destroyed.424			CollectionId,425			/// Identifier of burned NFT.426			TokenId,427			/// Which user has destroyed its tokens.428			T::CrossAccountId,429			/// Amount of token pieces destroed. Always 1 for NFT.430			u128,431		),432433		/// Item was transferred434		Transfer(435			/// Id of collection to which item is belong.436			CollectionId,437			/// Id of an item.438			TokenId,439			/// Original owner of item.440			T::CrossAccountId,441			/// New owner of item.442			T::CrossAccountId,443			/// Amount of token pieces transfered. Always 1 for NFT.444			u128,445		),446447		/// Amount pieces of token owned by `sender` was approved for `spender`.448		Approved(449			/// Id of collection to which item is belong.450			CollectionId,451			/// Id of an item.452			TokenId,453			/// Original owner of item.454			T::CrossAccountId,455			/// Id for which the approval was granted.456			T::CrossAccountId,457			/// Amount of token pieces transfered. Always 1 for NFT.458			u128,459		),460461		/// The colletion property has been added or edited.462		CollectionPropertySet(463			/// Id of collection to which property has been set.464			CollectionId,465			/// The property that was set.466			PropertyKey,467		),468469		/// The property has been deleted.470		CollectionPropertyDeleted(471			/// Id of collection to which property has been deleted.472			CollectionId,473			/// The property that was deleted.474			PropertyKey,475		),476477		/// The token property has been added or edited.478		TokenPropertySet(479			/// Identifier of the collection whose token has the property set.480			CollectionId,481			/// The token for which the property was set.482			TokenId,483			/// The property that was set.484			PropertyKey,485		),486487		/// The token property has been deleted.488		TokenPropertyDeleted(489			/// Identifier of the collection whose token has the property deleted.490			CollectionId,491			/// The token for which the property was deleted.492			TokenId,493			/// The property that was deleted.494			PropertyKey,495		),496497		/// The token property permission of a collection has been set.498		PropertyPermissionSet(499			/// ID of collection to which property permission has been set.500			CollectionId,501			/// The property permission that was set.502			PropertyKey,503		),504	}505506	#[pallet::error]507	pub enum Error<T> {508		/// This collection does not exist.509		CollectionNotFound,510		/// Sender parameter and item owner must be equal.511		MustBeTokenOwner,512		/// No permission to perform action513		NoPermission,514		/// Destroying only empty collections is allowed515		CantDestroyNotEmptyCollection,516		/// Collection is not in mint mode.517		PublicMintingNotAllowed,518		/// Address is not in allow list.519		AddressNotInAllowlist,520521		/// Collection name can not be longer than 63 char.522		CollectionNameLimitExceeded,523		/// Collection description can not be longer than 255 char.524		CollectionDescriptionLimitExceeded,525		/// Token prefix can not be longer than 15 char.526		CollectionTokenPrefixLimitExceeded,527		/// Total collections bound exceeded.528		TotalCollectionsLimitExceeded,529		/// Exceeded max admin count530		CollectionAdminCountExceeded,531		/// Collection limit bounds per collection exceeded532		CollectionLimitBoundsExceeded,533		/// Tried to enable permissions which are only permitted to be disabled534		OwnerPermissionsCantBeReverted,535		/// Collection settings not allowing items transferring536		TransferNotAllowed,537		/// Account token limit exceeded per collection538		AccountTokenLimitExceeded,539		/// Collection token limit exceeded540		CollectionTokenLimitExceeded,541		/// Metadata flag frozen542		MetadataFlagFrozen,543544		/// Item does not exist545		TokenNotFound,546		/// Item is balance not enough547		TokenValueTooLow,548		/// Requested value is more than the approved549		ApprovedValueTooLow,550		/// Tried to approve more than owned551		CantApproveMoreThanOwned,552553		/// Can't transfer tokens to ethereum zero address554		AddressIsZero,555556		/// The operation is not supported557		UnsupportedOperation,558559		/// Insufficient funds to perform an action560		NotSufficientFounds,561562		/// User does not satisfy the nesting rule563		UserIsNotAllowedToNest,564		/// Only tokens from specific collections may nest tokens under this one565		SourceCollectionIsNotAllowedToNest,566567		/// Tried to store more data than allowed in collection field568		CollectionFieldSizeExceeded,569570		/// Tried to store more property data than allowed571		NoSpaceForProperty,572573		/// Tried to store more property keys than allowed574		PropertyLimitReached,575576		/// Property key is too long577		PropertyKeyIsTooLong,578579		/// Only ASCII letters, digits, and symbols `_`, `-`, and `.` are allowed580		InvalidCharacterInPropertyKey,581582		/// Empty property keys are forbidden583		EmptyPropertyKey,584585		/// Tried to access an external collection with an internal API586		CollectionIsExternal,587588		/// Tried to access an internal collection with an external API589		CollectionIsInternal,590	}591592	/// Storage of the count of created collections. Essentially contains the last collection ID.593	#[pallet::storage]594	pub type CreatedCollectionCount<T> = StorageValue<Value = CollectionId, QueryKind = ValueQuery>;595596	/// Storage of the count of deleted collections.597	#[pallet::storage]598	pub type DestroyedCollectionCount<T> =599		StorageValue<Value = CollectionId, QueryKind = ValueQuery>;600601	/// Storage of collection info.602	#[pallet::storage]603	pub type CollectionById<T> = StorageMap<604		Hasher = Blake2_128Concat,605		Key = CollectionId,606		Value = Collection<<T as frame_system::Config>::AccountId>,607		QueryKind = OptionQuery,608	>;609610	/// Storage of collection properties.611	#[pallet::storage]612	#[pallet::getter(fn collection_properties)]613	pub type CollectionProperties<T> = StorageMap<614		Hasher = Blake2_128Concat,615		Key = CollectionId,616		Value = Properties,617		QueryKind = ValueQuery,618		OnEmpty = up_data_structs::CollectionProperties,619	>;620621	/// Storage of token property permissions of a collection.622	#[pallet::storage]623	#[pallet::getter(fn property_permissions)]624	pub type CollectionPropertyPermissions<T> = StorageMap<625		Hasher = Blake2_128Concat,626		Key = CollectionId,627		Value = PropertiesPermissionMap,628		QueryKind = ValueQuery,629	>;630631	/// Storage of the amount of collection admins.632	#[pallet::storage]633	pub type AdminAmount<T> = StorageMap<634		Hasher = Blake2_128Concat,635		Key = CollectionId,636		Value = u32,637		QueryKind = ValueQuery,638	>;639640	/// List of collection admins.641	#[pallet::storage]642	pub type IsAdmin<T: Config> = StorageNMap<643		Key = (644			Key<Blake2_128Concat, CollectionId>,645			Key<Blake2_128Concat, T::CrossAccountId>,646		),647		Value = bool,648		QueryKind = ValueQuery,649	>;650651	/// Allowlisted collection users.652	#[pallet::storage]653	pub type Allowlist<T: Config> = StorageNMap<654		Key = (655			Key<Blake2_128Concat, CollectionId>,656			Key<Blake2_128Concat, T::CrossAccountId>,657		),658		Value = bool,659		QueryKind = ValueQuery,660	>;661662	/// Not used by code, exists only to provide some types to metadata.663	#[pallet::storage]664	pub type DummyStorageValue<T: Config> = StorageValue<665		Value = (666			CollectionStats,667			CollectionId,668			TokenId,669			TokenChild,670			PhantomType<(671				TokenData<T::CrossAccountId>,672				RpcCollection<T::AccountId>,673				// RMRK674				RmrkCollectionInfo<T::AccountId>,675				RmrkInstanceInfo<T::AccountId>,676				RmrkResourceInfo,677				RmrkPropertyInfo,678				RmrkBaseInfo<T::AccountId>,679				RmrkPartType,680				RmrkBoundedTheme,681				RmrkNftChild,682			)>,683		),684		QueryKind = OptionQuery,685	>;686687	#[pallet::hooks]688	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {689		fn on_runtime_upgrade() -> Weight {690			StorageVersion::new(1).put::<Pallet<T>>();691692			0693		}694	}695}696697impl<T: Config> Pallet<T> {698	/// Enshure that receiver address is correct.699	///700	/// Ethereum receiver 0x0000000000000000000000000000000000000000 is reserved, and shouldn't own tokens.701	pub fn ensure_correct_receiver(receiver: &T::CrossAccountId) -> DispatchResult {702		ensure!(703			&T::CrossAccountId::from_eth(H160([0; 20])) != receiver,704			<Error<T>>::AddressIsZero705		);706		Ok(())707	}708709	/// Get a vector of collection admins.710	pub fn adminlist(collection: CollectionId) -> Vec<T::CrossAccountId> {711		<IsAdmin<T>>::iter_prefix((collection,))712			.map(|(a, _)| a)713			.collect()714	}715716	/// Get a vector of users allowed to mint tokens.717	pub fn allowlist(collection: CollectionId) -> Vec<T::CrossAccountId> {718		<Allowlist<T>>::iter_prefix((collection,))719			.map(|(a, _)| a)720			.collect()721	}722723	/// Is `user` allowed to mint token in `collection`.724	pub fn allowed(collection: CollectionId, user: T::CrossAccountId) -> bool {725		<Allowlist<T>>::get((collection, user))726	}727728	/// Get statistics of collections.729	pub fn collection_stats() -> CollectionStats {730		let created = <CreatedCollectionCount<T>>::get();731		let destroyed = <DestroyedCollectionCount<T>>::get();732		CollectionStats {733			created: created.0,734			destroyed: destroyed.0,735			alive: created.0 - destroyed.0,736		}737	}738739	/// Get the effective limits for the collection.740	pub fn effective_collection_limits(collection: CollectionId) -> Option<CollectionLimits> {741		let collection = <CollectionById<T>>::get(collection)?;742		let limits = collection.limits;743		let effective_limits = CollectionLimits {744			account_token_ownership_limit: Some(limits.account_token_ownership_limit()),745			sponsored_data_size: Some(limits.sponsored_data_size()),746			sponsored_data_rate_limit: Some(747				limits748					.sponsored_data_rate_limit749					.unwrap_or(SponsoringRateLimit::SponsoringDisabled),750			),751			token_limit: Some(limits.token_limit()),752			sponsor_transfer_timeout: Some(limits.sponsor_transfer_timeout(753				match collection.mode {754					CollectionMode::NFT => NFT_SPONSOR_TRANSFER_TIMEOUT,755					CollectionMode::Fungible(_) => FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,756					CollectionMode::ReFungible => REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,757				},758			)),759			sponsor_approve_timeout: Some(limits.sponsor_approve_timeout()),760			owner_can_transfer: Some(limits.owner_can_transfer()),761			owner_can_destroy: Some(limits.owner_can_destroy()),762			transfers_enabled: Some(limits.transfers_enabled()),763		};764765		Some(effective_limits)766	}767768	/// Returns information about the `collection` adapted for rpc.769	pub fn rpc_collection(collection: CollectionId) -> Option<RpcCollection<T::AccountId>> {770		let Collection {771			name,772			description,773			owner,774			mode,775			token_prefix,776			sponsorship,777			limits,778			permissions,779			external_collection,780		} = <CollectionById<T>>::get(collection)?;781782		let token_property_permissions = <CollectionPropertyPermissions<T>>::get(collection)783			.into_iter()784			.map(|(key, permission)| PropertyKeyPermission { key, permission })785			.collect();786787		let properties = <CollectionProperties<T>>::get(collection)788			.into_iter()789			.map(|(key, value)| Property { key, value })790			.collect();791792		let permissions = CollectionPermissions {793			access: Some(permissions.access()),794			mint_mode: Some(permissions.mint_mode()),795			nesting: Some(permissions.nesting().clone()),796		};797798		Some(RpcCollection {799			name: name.into_inner(),800			description: description.into_inner(),801			owner,802			mode,803			token_prefix: token_prefix.into_inner(),804			sponsorship,805			limits,806			permissions,807			token_property_permissions,808			properties,809			read_only: external_collection,810		})811	}812}813814macro_rules! limit_default {815	($old:ident, $new:ident, $($field:ident $(($arg:expr))? => $check:expr),* $(,)?) => {{816		$(817			if let Some($new) = $new.$field {818				let $old = $old.$field($($arg)?);819				let _ = $new;820				let _ = $old;821				$check822			} else {823				$new.$field = $old.$field824			}825		)*826	}};827}828macro_rules! limit_default_clone {829	($old:ident, $new:ident, $($field:ident $(($arg:expr))? => $check:expr),* $(,)?) => {{830		$(831			if let Some($new) = $new.$field.clone() {832				let $old = $old.$field($($arg)?);833				let _ = $new;834				let _ = $old;835				$check836			} else {837				$new.$field = $old.$field.clone()838			}839		)*840	}};841}842843impl<T: Config> Pallet<T> {844	/// Create new collection.845	///846	/// * `owner` - The owner of the collection.847	/// * `data` - Description of the created collection.848	/// * `is_external` - Marks that collection managet by not "Unique network".849	pub fn init_collection(850		owner: T::CrossAccountId,851		data: CreateCollectionData<T::AccountId>,852		is_external: bool,853	) -> Result<CollectionId, DispatchError> {854		{855			ensure!(856				data.token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH as usize,857				Error::<T>::CollectionTokenPrefixLimitExceeded858			);859		}860861		let created_count = <CreatedCollectionCount<T>>::get()862			.0863			.checked_add(1)864			.ok_or(ArithmeticError::Overflow)?;865		let destroyed_count = <DestroyedCollectionCount<T>>::get().0;866		let id = CollectionId(created_count);867868		// bound Total number of collections869		ensure!(870			created_count - destroyed_count <= COLLECTION_NUMBER_LIMIT,871			<Error<T>>::TotalCollectionsLimitExceeded872		);873874		// =========875876		let collection = Collection {877			owner: owner.as_sub().clone(),878			name: data.name,879			mode: data.mode.clone(),880			description: data.description,881			token_prefix: data.token_prefix,882			sponsorship: data883				.pending_sponsor884				.map(SponsorshipState::Unconfirmed)885				.unwrap_or_default(),886			limits: data887				.limits888				.map(|limits| Self::clamp_limits(data.mode.clone(), &Default::default(), limits))889				.unwrap_or_else(|| Ok(CollectionLimits::default()))?,890			permissions: data891				.permissions892				.map(|permissions| {893					Self::clamp_permissions(data.mode.clone(), &Default::default(), permissions)894				})895				.unwrap_or_else(|| Ok(CollectionPermissions::default()))?,896			external_collection: is_external,897		};898899		let mut collection_properties = up_data_structs::CollectionProperties::get();900		collection_properties901			.try_set_from_iter(data.properties.into_iter())902			.map_err(<Error<T>>::from)?;903904		CollectionProperties::<T>::insert(id, collection_properties);905906		let mut token_props_permissions = PropertiesPermissionMap::new();907		token_props_permissions908			.try_set_from_iter(data.token_property_permissions.into_iter())909			.map_err(<Error<T>>::from)?;910911		CollectionPropertyPermissions::<T>::insert(id, token_props_permissions);912913		// Take a (non-refundable) deposit of collection creation914		{915			let mut imbalance =916				<<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();917			imbalance.subsume(918				<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(919					&T::TreasuryAccountId::get(),920					T::CollectionCreationPrice::get(),921				),922			);923			<T as Config>::Currency::settle(924				owner.as_sub(),925				imbalance,926				WithdrawReasons::TRANSFER,927				ExistenceRequirement::KeepAlive,928			)929			.map_err(|_| Error::<T>::NotSufficientFounds)?;930		}931932		<CreatedCollectionCount<T>>::put(created_count);933		<Pallet<T>>::deposit_event(Event::CollectionCreated(934			id,935			data.mode.id(),936			owner.as_sub().clone(),937		));938		<PalletEvm<T>>::deposit_log(939			erc::CollectionHelpersEvents::CollectionCreated {940				owner: *owner.as_eth(),941				collection_id: eth::collection_id_to_address(id),942			}943			.to_log(T::ContractAddress::get()),944		);945		<CollectionById<T>>::insert(id, collection);946		Ok(id)947	}948949	/// Destroy collection.950	///951	/// * `collection` - Collection handler.952	/// * `sender` - The owner or administrator of the collection.953	pub fn destroy_collection(954		collection: CollectionHandle<T>,955		sender: &T::CrossAccountId,956	) -> DispatchResult {957		ensure!(958			collection.limits.owner_can_destroy(),959			<Error<T>>::NoPermission,960		);961		collection.check_is_owner(sender)?;962963		let destroyed_collections = <DestroyedCollectionCount<T>>::get()964			.0965			.checked_add(1)966			.ok_or(ArithmeticError::Overflow)?;967968		// =========969970		<DestroyedCollectionCount<T>>::put(destroyed_collections);971		<CollectionById<T>>::remove(collection.id);972		<AdminAmount<T>>::remove(collection.id);973		let _ = <IsAdmin<T>>::clear_prefix((collection.id,), u32::MAX, None);974		let _ = <Allowlist<T>>::clear_prefix((collection.id,), u32::MAX, None);975		<CollectionProperties<T>>::remove(collection.id);976977		<Pallet<T>>::deposit_event(Event::CollectionDestroyed(collection.id));978		Ok(())979	}980981	/// Set collection property.982	///983	/// * `collection` - Collection handler.984	/// * `sender` - The owner or administrator of the collection.985	/// * `property` - The property to set.986	pub fn set_collection_property(987		collection: &CollectionHandle<T>,988		sender: &T::CrossAccountId,989		property: Property,990	) -> DispatchResult {991		collection.check_is_owner_or_admin(sender)?;992993		CollectionProperties::<T>::try_mutate(collection.id, |properties| {994			let property = property.clone();995			properties.try_set(property.key, property.value)996		})997		.map_err(<Error<T>>::from)?;998999		Self::deposit_event(Event::CollectionPropertySet(collection.id, property.key));10001001		Ok(())1002	}10031004	/// Set scouped collection property.1005	///1006	/// * `collection_id` - ID of the collection for which the property is being set.1007	/// * `scope` - Property scope.1008	/// * `property` - The property to set.1009	pub fn set_scoped_collection_property(1010		collection_id: CollectionId,1011		scope: PropertyScope,1012		property: Property,1013	) -> DispatchResult {1014		CollectionProperties::<T>::try_mutate(collection_id, |properties| {1015			properties.try_scoped_set(scope, property.key, property.value)1016		})1017		.map_err(<Error<T>>::from)?;10181019		Ok(())1020	}10211022	/// Set scouped collection properties.1023	///1024	/// * `collection_id` - ID of the collection for which the properties is being set.1025	/// * `scope` - Property scope.1026	/// * `properties` - The properties to set.1027	pub fn set_scoped_collection_properties(1028		collection_id: CollectionId,1029		scope: PropertyScope,1030		properties: impl Iterator<Item = Property>,1031	) -> DispatchResult {1032		CollectionProperties::<T>::try_mutate(collection_id, |stored_properties| {1033			stored_properties.try_scoped_set_from_iter(scope, properties)1034		})1035		.map_err(<Error<T>>::from)?;10361037		Ok(())1038	}10391040	/// Set collection properties.1041	///1042	/// * `collection` - Collection handler.1043	/// * `sender` - The owner or administrator of the collection.1044	/// * `properties` - The properties to set.1045	#[transactional]1046	pub fn set_collection_properties(1047		collection: &CollectionHandle<T>,1048		sender: &T::CrossAccountId,1049		properties: Vec<Property>,1050	) -> DispatchResult {1051		for property in properties {1052			Self::set_collection_property(collection, sender, property)?;1053		}10541055		Ok(())1056	}10571058	/// Delete collection property.1059	///1060	/// * `collection` - Collection handler.1061	/// * `sender` - The owner or administrator of the collection.1062	/// * `property` - The property to delete.1063	pub fn delete_collection_property(1064		collection: &CollectionHandle<T>,1065		sender: &T::CrossAccountId,1066		property_key: PropertyKey,1067	) -> DispatchResult {1068		collection.check_is_owner_or_admin(sender)?;10691070		CollectionProperties::<T>::try_mutate(collection.id, |properties| {1071			properties.remove(&property_key)1072		})1073		.map_err(<Error<T>>::from)?;10741075		Self::deposit_event(Event::CollectionPropertyDeleted(1076			collection.id,1077			property_key,1078		));10791080		Ok(())1081	}10821083	/// Delete collection properties.1084	///1085	/// * `collection` - Collection handler.1086	/// * `sender` - The owner or administrator of the collection.1087	/// * `properties` - The properties to delete.1088	#[transactional]1089	pub fn delete_collection_properties(1090		collection: &CollectionHandle<T>,1091		sender: &T::CrossAccountId,1092		property_keys: Vec<PropertyKey>,1093	) -> DispatchResult {1094		for key in property_keys {1095			Self::delete_collection_property(collection, sender, key)?;1096		}10971098		Ok(())1099	}11001101	/// Set collection propetry permission without any checks.1102	///1103	/// Used for migrations.1104	///1105	/// * `collection` - Collection handler.1106	/// * `property_permissions` - Property permissions.1107	pub fn set_property_permission_unchecked(1108		collection: CollectionId,1109		property_permission: PropertyKeyPermission,1110	) -> DispatchResult {1111		<CollectionPropertyPermissions<T>>::try_mutate(collection, |permissions| {1112			permissions.try_set(property_permission.key, property_permission.permission)1113		})1114		.map_err(<Error<T>>::from)?;1115		Ok(())1116	}11171118	/// Set collection property permission.1119	///1120	/// * `collection` - Collection handler.1121	/// * `sender` - The owner or administrator of the collection.1122	/// * `property_permission` - Property permission.1123	pub fn set_property_permission(1124		collection: &CollectionHandle<T>,1125		sender: &T::CrossAccountId,1126		property_permission: PropertyKeyPermission,1127	) -> DispatchResult {1128		Self::set_scoped_property_permission(1129			collection,1130			sender,1131			PropertyScope::None,1132			property_permission,1133		)1134	}11351136	/// Set collection property permission with scope.1137	///1138	/// * `collection` - Collection handler.1139	/// * `sender` - The owner or administrator of the collection.1140	/// * `scope` - Property scope.1141	/// * `property_permission` - Property permission.1142	pub fn set_scoped_property_permission(1143		collection: &CollectionHandle<T>,1144		sender: &T::CrossAccountId,1145		scope: PropertyScope,1146		property_permission: PropertyKeyPermission,1147	) -> DispatchResult {1148		collection.check_is_owner_or_admin(sender)?;11491150		let all_permissions = CollectionPropertyPermissions::<T>::get(collection.id);1151		let current_permission = all_permissions.get(&property_permission.key);1152		if matches![1153			current_permission,1154			Some(PropertyPermission { mutable: false, .. })1155		] {1156			return Err(<Error<T>>::NoPermission.into());1157		}11581159		CollectionPropertyPermissions::<T>::try_mutate(collection.id, |permissions| {1160			let property_permission = property_permission.clone();1161			permissions.try_scoped_set(1162				scope,1163				property_permission.key,1164				property_permission.permission,1165			)1166		})1167		.map_err(<Error<T>>::from)?;11681169		Self::deposit_event(Event::PropertyPermissionSet(1170			collection.id,1171			property_permission.key,1172		));11731174		Ok(())1175	}11761177	/// Set token property permission.1178	///1179	/// * `collection` - Collection handler.1180	/// * `sender` - The owner or administrator of the collection.1181	/// * `property_permissions` - Property permissions.1182	#[transactional]1183	pub fn set_token_property_permissions(1184		collection: &CollectionHandle<T>,1185		sender: &T::CrossAccountId,1186		property_permissions: Vec<PropertyKeyPermission>,1187	) -> DispatchResult {1188		Self::set_scoped_token_property_permissions(1189			collection,1190			sender,1191			PropertyScope::None,1192			property_permissions,1193		)1194	}11951196	/// Set token property permission with scope.1197	///1198	/// * `collection` - Collection handler.1199	/// * `sender` - The owner or administrator of the collection.1200	/// * `scope` - Property scope.1201	/// * `property_permissions` - Property permissions.1202	#[transactional]1203	pub fn set_scoped_token_property_permissions(1204		collection: &CollectionHandle<T>,1205		sender: &T::CrossAccountId,1206		scope: PropertyScope,1207		property_permissions: Vec<PropertyKeyPermission>,1208	) -> DispatchResult {1209		for prop_pemission in property_permissions {1210			Self::set_scoped_property_permission(collection, sender, scope, 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	($runtime:path) => {1415		Err($crate::Error::<$runtime>::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	}14901491	/// The price of retrieving token owner1492	fn token_owner() -> Weight;1493}14941495/// Weight info extension trait for refungible pallet.1496pub trait RefungibleExtensionsWeightInfo {1497	/// Weight of token repartition.1498	fn repartition() -> Weight;1499}15001501/// Common collection operations.1502///1503/// It wraps methods in Fungible, Nonfungible and Refungible pallets1504/// and adds weight info.1505pub trait CommonCollectionOperations<T: Config> {1506	/// Create token.1507	///1508	/// * `sender` - The user who mint the token and pays for the transaction.1509	/// * `to` - The user who will own the token.1510	/// * `data` - Token data.1511	/// * `nesting_budget` - A budget that can be spent on nesting tokens.1512	fn create_item(1513		&self,1514		sender: T::CrossAccountId,1515		to: T::CrossAccountId,1516		data: CreateItemData,1517		nesting_budget: &dyn Budget,1518	) -> DispatchResultWithPostInfo;15191520	/// Create multiple tokens.1521	///1522	/// * `sender` - The user who mint the token and pays for the transaction.1523	/// * `to` - The user who will own the token.1524	/// * `data` - Token data.1525	/// * `nesting_budget` - A budget that can be spent on nesting tokens.1526	fn create_multiple_items(1527		&self,1528		sender: T::CrossAccountId,1529		to: T::CrossAccountId,1530		data: Vec<CreateItemData>,1531		nesting_budget: &dyn Budget,1532	) -> DispatchResultWithPostInfo;15331534	/// Create multiple tokens.1535	///1536	/// * `sender` - The user who mint the token and pays for the transaction.1537	/// * `to` - The user who will own the token.1538	/// * `data` - Token data.1539	/// * `nesting_budget` - A budget that can be spent on nesting tokens.1540	fn create_multiple_items_ex(1541		&self,1542		sender: T::CrossAccountId,1543		data: CreateItemExData<T::CrossAccountId>,1544		nesting_budget: &dyn Budget,1545	) -> DispatchResultWithPostInfo;15461547	/// Burn token.1548	///1549	/// * `sender` - The user who owns the token.1550	/// * `token` - Token id that will burned.1551	/// * `amount` - The number of parts of the token that will be burned.1552	fn burn_item(1553		&self,1554		sender: T::CrossAccountId,1555		token: TokenId,1556		amount: u128,1557	) -> DispatchResultWithPostInfo;15581559	/// Burn token and all nested tokens recursievly.1560	///1561	/// * `sender` - The user who owns the token.1562	/// * `token` - Token id that will burned.1563	/// * `self_budget` - The budget that can be spent on burning tokens.1564	/// * `breadth_budget` - The budget that can be spent on burning nested tokens.1565	fn burn_item_recursively(1566		&self,1567		sender: T::CrossAccountId,1568		token: TokenId,1569		self_budget: &dyn Budget,1570		breadth_budget: &dyn Budget,1571	) -> DispatchResultWithPostInfo;15721573	/// Set collection properties.1574	///1575	/// * `sender` - Must be either the owner of the collection or its admin.1576	/// * `properties` - Properties to be set.1577	fn set_collection_properties(1578		&self,1579		sender: T::CrossAccountId,1580		properties: Vec<Property>,1581	) -> DispatchResultWithPostInfo;15821583	/// Delete collection properties.1584	///1585	/// * `sender` - Must be either the owner of the collection or its admin.1586	/// * `properties` - The properties to be removed.1587	fn delete_collection_properties(1588		&self,1589		sender: &T::CrossAccountId,1590		property_keys: Vec<PropertyKey>,1591	) -> DispatchResultWithPostInfo;15921593	/// Set token properties.1594	///1595	/// The appropriate [`PropertyPermission`] for the token property1596	/// must be set with [`Self::set_token_property_permissions`].1597	///1598	/// * `sender` - Must be either the owner of the token or its admin.1599	/// * `token_id` - The token for which the properties are being set.1600	/// * `properties` - Properties to be set.1601	/// * `budget` - Budget for setting properties.1602	fn set_token_properties(1603		&self,1604		sender: T::CrossAccountId,1605		token_id: TokenId,1606		properties: Vec<Property>,1607		budget: &dyn Budget,1608	) -> DispatchResultWithPostInfo;16091610	/// Remove token properties.1611	///1612	/// The appropriate [`PropertyPermission`] for the token property1613	/// must be set with [`Self::set_token_property_permissions`].1614	///1615	/// * `sender` - Must be either the owner of the token or its admin.1616	/// * `token_id` - The token for which the properties are being remove.1617	/// * `property_keys` - Keys to remove corresponding properties.1618	/// * `budget` - Budget for removing properties.1619	fn delete_token_properties(1620		&self,1621		sender: T::CrossAccountId,1622		token_id: TokenId,1623		property_keys: Vec<PropertyKey>,1624		budget: &dyn Budget,1625	) -> DispatchResultWithPostInfo;16261627	/// Set token property permissions.1628	///1629	/// * `sender` - Must be either the owner of the token or its admin.1630	/// * `token_id` - The token for which the properties are being set.1631	/// * `property_permissions` - Property permissions to be set.1632	/// * `budget` - Budget for setting properties.1633	fn set_token_property_permissions(1634		&self,1635		sender: &T::CrossAccountId,1636		property_permissions: Vec<PropertyKeyPermission>,1637	) -> DispatchResultWithPostInfo;16381639	/// Transfer amount of token pieces.1640	///1641	/// * `sender` - Donor user.1642	/// * `to` - Recepient user.1643	/// * `token` - The token of which parts are being sent.1644	/// * `amount` - The number of parts of the token that will be transferred.1645	/// * `budget` - The maximum budget that can be spent on the transfer.1646	fn transfer(1647		&self,1648		sender: T::CrossAccountId,1649		to: T::CrossAccountId,1650		token: TokenId,1651		amount: u128,1652		budget: &dyn Budget,1653	) -> DispatchResultWithPostInfo;16541655	/// Grant access to another account to transfer parts of the token owned by the calling user via [Self::transfer_from].1656	///1657	/// * `sender` - The user who grants access to the token.1658	/// * `spender` - The user to whom the rights are granted.1659	/// * `token` - The token to which access is granted.1660	/// * `amount` - The amount of pieces that another user can dispose of.1661	fn approve(1662		&self,1663		sender: T::CrossAccountId,1664		spender: T::CrossAccountId,1665		token: TokenId,1666		amount: u128,1667	) -> DispatchResultWithPostInfo;16681669	/// Send parts of a token owned by another user.1670	///1671	/// Before calling this method, you must grant rights to the calling user via [`Self::approve`].1672	///1673	/// * `sender` - The user who must have access to the token (see [`Self::approve`]).1674	/// * `from` - The user who owns the token.1675	/// * `to` - Recepient user.1676	/// * `token` - The token of which parts are being sent.1677	/// * `amount` - The number of parts of the token that will be transferred.1678	/// * `budget` - The maximum budget that can be spent on the transfer.1679	fn transfer_from(1680		&self,1681		sender: T::CrossAccountId,1682		from: T::CrossAccountId,1683		to: T::CrossAccountId,1684		token: TokenId,1685		amount: u128,1686		budget: &dyn Budget,1687	) -> DispatchResultWithPostInfo;16881689	/// Burn parts of a token owned by another user.1690	///1691	/// Before calling this method, you must grant rights to the calling user via [`Self::approve`].1692	///1693	/// * `sender` - The user who must have access to the token (see [`Self::approve`]).1694	/// * `from` - The user who owns the token.1695	/// * `token` - The token of which parts are being sent.1696	/// * `amount` - The number of parts of the token that will be transferred.1697	/// * `budget` - The maximum budget that can be spent on the burn.1698	fn burn_from(1699		&self,1700		sender: T::CrossAccountId,1701		from: T::CrossAccountId,1702		token: TokenId,1703		amount: u128,1704		budget: &dyn Budget,1705	) -> DispatchResultWithPostInfo;17061707	/// Check permission to nest token.1708	///1709	/// * `sender` - The user who initiated the check.1710	/// * `from` - The token that is checked for embedding.1711	/// * `under` - Token under which to check.1712	/// * `budget` - The maximum budget that can be spent on the check.1713	fn check_nesting(1714		&self,1715		sender: T::CrossAccountId,1716		from: (CollectionId, TokenId),1717		under: TokenId,1718		budget: &dyn Budget,1719	) -> DispatchResult;17201721	/// Nest one token into another.1722	///1723	/// * `under` - Token holder.1724	/// * `to_nest` - Nested token.1725	fn nest(&self, under: TokenId, to_nest: (CollectionId, TokenId));17261727	/// Unnest token.1728	///1729	/// * `under` - Token holder.1730	/// * `to_nest` - Token to unnest.1731	fn unnest(&self, under: TokenId, to_nest: (CollectionId, TokenId));17321733	/// Get all user tokens.1734	///1735	/// * `account` - Account for which you need to get tokens.1736	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId>;17371738	/// Get all the tokens in the collection.1739	fn collection_tokens(&self) -> Vec<TokenId>;17401741	/// Check if the token exists.1742	///1743	/// * `token` - Id token to check.1744	fn token_exists(&self, token: TokenId) -> bool;17451746	/// Get the id of the last minted token.1747	fn last_token_id(&self) -> TokenId;17481749	/// Get the owner of the token.1750	///1751	/// * `token` - The token for which you need to find out the owner.1752	fn token_owner(&self, token: TokenId) -> Option<T::CrossAccountId>;17531754	/// Returns 10 tokens owners in no particular order.1755	///1756	/// * `token` - The token for which you need to find out the owners.1757	fn token_owners(&self, token: TokenId) -> Vec<T::CrossAccountId>;17581759	/// Get the value of the token property by key.1760	///1761	/// * `token` - Token with the property to get.1762	/// * `key` - Property name.1763	fn token_property(&self, token_id: TokenId, key: &PropertyKey) -> Option<PropertyValue>;17641765	/// Get a set of token properties by key vector.1766	///1767	/// * `token` - Token with the property to get.1768	/// * `keys` - Vector of property keys. If this parameter is [None](sp_std::result::Result),1769	/// then all properties are returned.1770	fn token_properties(&self, token: TokenId, keys: Option<Vec<PropertyKey>>) -> Vec<Property>;17711772	/// Amount of unique collection tokens1773	fn total_supply(&self) -> u32;17741775	/// Amount of different tokens account has.1776	///1777	/// * `account` - The account for which need to get the balance.1778	fn account_balance(&self, account: T::CrossAccountId) -> u32;17791780	/// Amount of specific token account have.1781	fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128;17821783	/// Amount of token pieces1784	fn total_pieces(&self, token: TokenId) -> Option<u128>;17851786	/// Get the number of parts of the token that a trusted user can manage.1787	///1788	/// * `sender` - Trusted user.1789	/// * `spender` - Owner of the token.1790	/// * `token` - The token for which to get the value.1791	fn allowance(1792		&self,1793		sender: T::CrossAccountId,1794		spender: T::CrossAccountId,1795		token: TokenId,1796	) -> u128;17971798	/// Get extension for RFT collection.1799	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>>;1800}18011802/// Extension for RFT collection.1803pub trait RefungibleExtensions<T>1804where1805	T: Config,1806{1807	/// Change the number of parts of the token.1808	///1809	/// When the value changes down, this function is equivalent to burning parts of the token.1810	///1811	/// * `sender` - The user calling the repartition operation. Must be the owner of the token.1812	/// * `token` - The token for which you want to change the number of parts.1813	/// * `amount` - The new value of the parts of the token.1814	fn repartition(1815		&self,1816		sender: &T::CrossAccountId,1817		token: TokenId,1818		amount: u128,1819	) -> DispatchResultWithPostInfo;1820}18211822/// Merge [`DispatchResult`] with [`Weight`] into [`DispatchResultWithPostInfo`].1823///1824/// Used for [`CommonCollectionOperations`] implementations and flexible enough to do so.1825pub fn with_weight(res: DispatchResult, weight: Weight) -> DispatchResultWithPostInfo {1826	let post_info = PostDispatchInfo {1827		actual_weight: Some(weight),1828		pays_fee: Pays::Yes,1829	};1830	match res {1831		Ok(()) => Ok(post_info),1832		Err(error) => Err(DispatchErrorWithPostInfo { post_info, error }),1833	}1834}18351836impl<T: Config> From<PropertiesError> for Error<T> {1837	fn from(error: PropertiesError) -> Self {1838		match error {1839			PropertiesError::NoSpaceForProperty => Self::NoSpaceForProperty,1840			PropertiesError::PropertyLimitReached => Self::PropertyLimitReached,1841			PropertiesError::InvalidCharacterInPropertyKey => Self::InvalidCharacterInPropertyKey,1842			PropertiesError::PropertyKeyIsTooLong => Self::PropertyKeyIsTooLong,1843			PropertiesError::EmptyPropertyKey => Self::EmptyPropertyKey,1844		}1845	}1846}