git.delta.rocks / unique-network / refs/commits / 7d1c4da161ca

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};116117pub use pallet::*;118use sp_core::H160;119use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};120#[cfg(feature = "runtime-benchmarks")]121pub mod benchmarking;122pub mod dispatch;123pub mod erc;124pub mod eth;125pub mod weights;126127/// Weight info.128pub type SelfWeightOf<T> = <T as Config>::WeightInfo;129130/// Collection handle contains information about collection data and id.131/// Also provides functionality to count consumed gas.132///133/// CollectionHandle is used as a generic wrapper for collections of all types.134/// It allows to perform common operations and queries on any collection type,135/// both completely general for all, as well as their respective implementations of [`CommonCollectionOperations`].136#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]137pub struct CollectionHandle<T: Config> {138	/// Collection id139	pub id: CollectionId,140	collection: Collection<T::AccountId>,141	/// Substrate recorder for counting consumed gas142	pub recorder: SubstrateRecorder<T>,143}144145impl<T: Config> WithRecorder<T> for CollectionHandle<T> {146	fn recorder(&self) -> &SubstrateRecorder<T> {147		&self.recorder148	}149	fn into_recorder(self) -> SubstrateRecorder<T> {150		self.recorder151	}152}153154impl<T: Config> CollectionHandle<T> {155	/// Same as [CollectionHandle::new] but with an explicit gas limit.156	pub fn new_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {157		<CollectionById<T>>::get(id).map(|collection| Self {158			id,159			collection,160			recorder: SubstrateRecorder::new(gas_limit),161		})162	}163164	/// Same as [CollectionHandle::new] but with an existed [`SubstrateRecorder`].165	pub fn new_with_recorder(id: CollectionId, recorder: SubstrateRecorder<T>) -> Option<Self> {166		<CollectionById<T>>::get(id).map(|collection| Self {167			id,168			collection,169			recorder,170		})171	}172173	/// Retrives collection data from storage and creates collection handle with default parameters.174	/// If collection not found return `None`175	pub fn new(id: CollectionId) -> Option<Self> {176		Self::new_with_gas_limit(id, u64::MAX)177	}178179	/// Same as [`CollectionHandle::new`] but if collection not found [CollectionNotFound](Error::CollectionNotFound) returned.180	pub fn try_get(id: CollectionId) -> Result<Self, DispatchError> {181		Ok(Self::new(id).ok_or(<Error<T>>::CollectionNotFound)?)182	}183184	/// Consume gas for reading.185	pub fn consume_store_reads(&self, reads: u64) -> evm_coder::execution::Result<()> {186		self.recorder187			.consume_gas(T::GasWeightMapping::weight_to_gas(188				<T as frame_system::Config>::DbWeight::get()189					.read190					.saturating_mul(reads),191			))192	}193194	/// Consume gas for writing.195	pub fn consume_store_writes(&self, writes: u64) -> evm_coder::execution::Result<()> {196		self.recorder197			.consume_gas(T::GasWeightMapping::weight_to_gas(198				<T as frame_system::Config>::DbWeight::get()199					.write200					.saturating_mul(writes),201			))202	}203204	/// Consume gas for reading and writing.205	pub fn consume_store_reads_and_writes(206		&self,207		reads: u64,208		writes: u64,209	) -> evm_coder::execution::Result<()> {210		let weight = <T as frame_system::Config>::DbWeight::get();211		let reads = weight.read.saturating_mul(reads);212		let writes = weight.read.saturating_mul(writes);213		self.recorder214			.consume_gas(T::GasWeightMapping::weight_to_gas(215				reads.saturating_add(writes),216			))217	}218219	/// Save collection to storage.220	pub fn save(&self) -> DispatchResult {221		<CollectionById<T>>::insert(self.id, &self.collection);222		Ok(())223	}224225	/// Set collection sponsor.226	///227	/// Unique collections allows sponsoring for certain actions.228	/// This method allows you to set the sponsor of the collection.229	/// In order for sponsorship to become active, it must be confirmed through [`Self::confirm_sponsorship`].230	pub fn set_sponsor(&mut self, sponsor: T::AccountId) -> DispatchResult {231		self.collection.sponsorship = SponsorshipState::Unconfirmed(sponsor);232		Ok(())233	}234235	/// Confirm sponsorship236	///237	/// In order for the sponsorship to become active, the user set as the sponsor must confirm their participation.238	/// Before confirming sponsorship, the user must be specified as the sponsor of the collection via [`Self::set_sponsor`].239	pub fn confirm_sponsorship(&mut self, sender: &T::AccountId) -> Result<bool, DispatchError> {240		if self.collection.sponsorship.pending_sponsor() != Some(sender) {241			return Ok(false);242		}243244		self.collection.sponsorship = SponsorshipState::Confirmed(sender.clone());245		Ok(true)246	}247248	/// Remove collection sponsor.249	pub fn remove_sponsor(&mut self) -> DispatchResult {250		self.collection.sponsorship = SponsorshipState::Disabled;251		Ok(())252	}253254	/// Checks that the collection was created with, and must be operated upon through **Unique API**.255	/// Now check only the `external_collection` flag and if it's **true**, then return [`Error::CollectionIsExternal`] error.256	pub fn check_is_internal(&self) -> DispatchResult {257		if self.external_collection {258			return Err(<Error<T>>::CollectionIsExternal)?;259		}260261		Ok(())262	}263264	/// Checks that the collection was created with, and must be operated upon through an **assimilated API**.265	/// Now check only the `external_collection` flag and if it's **false**, then return [`Error::CollectionIsInternal`] error.266	pub fn check_is_external(&self) -> DispatchResult {267		if !self.external_collection {268			return Err(<Error<T>>::CollectionIsInternal)?;269		}270271		Ok(())272	}273}274275impl<T: Config> Deref for CollectionHandle<T> {276	type Target = Collection<T::AccountId>;277278	fn deref(&self) -> &Self::Target {279		&self.collection280	}281}282283impl<T: Config> DerefMut for CollectionHandle<T> {284	fn deref_mut(&mut self) -> &mut Self::Target {285		&mut self.collection286	}287}288289impl<T: Config> CollectionHandle<T> {290	/// Checks if the `user` is the owner of the collection.291	pub fn check_is_owner(&self, user: &T::CrossAccountId) -> DispatchResult {292		ensure!(*user.as_sub() == self.owner, <Error<T>>::NoPermission);293		Ok(())294	}295296	/// Returns **true** if the `user` is the owner or administrator of the collection.297	pub fn is_owner_or_admin(&self, user: &T::CrossAccountId) -> bool {298		*user.as_sub() == self.owner || <IsAdmin<T>>::get((self.id, user))299	}300301	/// Checks if the `user` is the owner or administrator of the collection.302	pub fn check_is_owner_or_admin(&self, user: &T::CrossAccountId) -> DispatchResult {303		ensure!(self.is_owner_or_admin(user), <Error<T>>::NoPermission);304		Ok(())305	}306307	/// Return **true** if `user` was not allowed to have tokens, and he can ignore such restrictions.308	pub fn ignores_allowance(&self, user: &T::CrossAccountId) -> bool {309		self.limits.owner_can_transfer() && self.is_owner_or_admin(user)310	}311312	/// Return **true** if `user` does not have enough token parts, and he can ignore such restrictions.313	pub fn ignores_owned_amount(&self, user: &T::CrossAccountId) -> bool {314		self.limits.owner_can_transfer() && self.is_owner_or_admin(user)315	}316317	/// Checks if the user is in the allow list. If not [Error::AddressNotInAllowlist] returns.318	pub fn check_allowlist(&self, user: &T::CrossAccountId) -> DispatchResult {319		ensure!(320			<Allowlist<T>>::get((self.id, user)),321			<Error<T>>::AddressNotInAllowlist322		);323		Ok(())324	}325326	/// Changes collection owner to another account327	/// #### Store read/writes328	/// 1 writes329	fn set_owner_internal(330		&mut self,331		caller: T::CrossAccountId,332		new_owner: T::CrossAccountId,333	) -> DispatchResult {334		self.check_is_owner(&caller)?;335		self.collection.owner = new_owner.as_sub().clone();336		self.save()337	}338}339340#[frame_support::pallet]341pub mod pallet {342	use super::*;343	use pallet_evm::account;344	use dispatch::CollectionDispatch;345	use frame_support::{Blake2_128Concat, pallet_prelude::*, storage::Key, traits::StorageVersion};346	use frame_system::pallet_prelude::*;347	use frame_support::traits::Currency;348	use up_data_structs::{TokenId, mapping::TokenAddressMapping};349	use scale_info::TypeInfo;350	use weights::WeightInfo;351352	#[pallet::config]353	pub trait Config:354		frame_system::Config355		+ pallet_evm_coder_substrate::Config356		+ pallet_evm::Config357		+ TypeInfo358		+ account::Config359	{360		/// Weight information for functions of this pallet.361		type WeightInfo: WeightInfo;362363		/// Events compatible with [`frame_system::Config::Event`].364		type Event: IsType<<Self as frame_system::Config>::Event> + From<Event<Self>>;365366		/// Handler of accounts and payment.367		type Currency: Currency<Self::AccountId>;368369		/// Set price to create a collection.370		#[pallet::constant]371		type CollectionCreationPrice: Get<372			<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,373		>;374375		/// Dispatcher of operations on collections.376		type CollectionDispatch: CollectionDispatch<Self>;377378		/// Account which holds the chain's treasury.379		type TreasuryAccountId: Get<Self::AccountId>;380381		/// Address under which the CollectionHelper contract would be available.382		type ContractAddress: Get<H160>;383384		/// Mapper for token addresses to Ethereum addresses.385		type EvmTokenAddressMapping: TokenAddressMapping<H160>;386387		/// Mapper for token addresses to [`CrossAccountId`].388		type CrossTokenAddressMapping: TokenAddressMapping<Self::CrossAccountId>;389	}390391	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);392393	#[pallet::pallet]394	#[pallet::storage_version(STORAGE_VERSION)]395	#[pallet::generate_store(pub(super) trait Store)]396	pub struct Pallet<T>(_);397398	#[pallet::extra_constants]399	impl<T: Config> Pallet<T> {400		/// Maximum admins per collection.401		pub fn collection_admins_limit() -> u32 {402			COLLECTION_ADMINS_LIMIT403		}404	}405406	#[pallet::event]407	#[pallet::generate_deposit(pub fn deposit_event)]408	pub enum Event<T: Config> {409		/// New collection was created410		CollectionCreated(411			/// Globally unique identifier of newly created collection.412			CollectionId,413			/// [`CollectionMode`] converted into _u8_.414			u8,415			/// Collection owner.416			T::AccountId,417		),418419		/// New collection was destroyed420		CollectionDestroyed(421			/// Globally unique identifier of collection.422			CollectionId,423		),424425		/// New item was created.426		ItemCreated(427			/// Id of the collection where item was created.428			CollectionId,429			/// Id of an item. Unique within the collection.430			TokenId,431			/// Owner of newly created item432			T::CrossAccountId,433			/// Always 1 for NFT434			u128,435		),436437		/// Collection item was burned.438		ItemDestroyed(439			/// Id of the collection where item was destroyed.440			CollectionId,441			/// Identifier of burned NFT.442			TokenId,443			/// Which user has destroyed its tokens.444			T::CrossAccountId,445			/// Amount of token pieces destroed. Always 1 for NFT.446			u128,447		),448449		/// Item was transferred450		Transfer(451			/// Id of collection to which item is belong.452			CollectionId,453			/// Id of an item.454			TokenId,455			/// Original owner of item.456			T::CrossAccountId,457			/// New owner of item.458			T::CrossAccountId,459			/// Amount of token pieces transfered. Always 1 for NFT.460			u128,461		),462463		/// Amount pieces of token owned by `sender` was approved for `spender`.464		Approved(465			/// Id of collection to which item is belong.466			CollectionId,467			/// Id of an item.468			TokenId,469			/// Original owner of item.470			T::CrossAccountId,471			/// Id for which the approval was granted.472			T::CrossAccountId,473			/// Amount of token pieces transfered. Always 1 for NFT.474			u128,475		),476477		/// The colletion property has been added or edited.478		CollectionPropertySet(479			/// Id of collection to which property has been set.480			CollectionId,481			/// The property that was set.482			PropertyKey,483		),484485		/// The property has been deleted.486		CollectionPropertyDeleted(487			/// Id of collection to which property has been deleted.488			CollectionId,489			/// The property that was deleted.490			PropertyKey,491		),492493		/// The token property has been added or edited.494		TokenPropertySet(495			/// Identifier of the collection whose token has the property set.496			CollectionId,497			/// The token for which the property was set.498			TokenId,499			/// The property that was set.500			PropertyKey,501		),502503		/// The token property has been deleted.504		TokenPropertyDeleted(505			/// Identifier of the collection whose token has the property deleted.506			CollectionId,507			/// The token for which the property was deleted.508			TokenId,509			/// The property that was deleted.510			PropertyKey,511		),512513		/// The token property permission of a collection has been set.514		PropertyPermissionSet(515			/// ID of collection to which property permission has been set.516			CollectionId,517			/// The property permission that was set.518			PropertyKey,519		),520	}521522	#[pallet::error]523	pub enum Error<T> {524		/// This collection does not exist.525		CollectionNotFound,526		/// Sender parameter and item owner must be equal.527		MustBeTokenOwner,528		/// No permission to perform action529		NoPermission,530		/// Destroying only empty collections is allowed531		CantDestroyNotEmptyCollection,532		/// Collection is not in mint mode.533		PublicMintingNotAllowed,534		/// Address is not in allow list.535		AddressNotInAllowlist,536537		/// Collection name can not be longer than 63 char.538		CollectionNameLimitExceeded,539		/// Collection description can not be longer than 255 char.540		CollectionDescriptionLimitExceeded,541		/// Token prefix can not be longer than 15 char.542		CollectionTokenPrefixLimitExceeded,543		/// Total collections bound exceeded.544		TotalCollectionsLimitExceeded,545		/// Exceeded max admin count546		CollectionAdminCountExceeded,547		/// Collection limit bounds per collection exceeded548		CollectionLimitBoundsExceeded,549		/// Tried to enable permissions which are only permitted to be disabled550		OwnerPermissionsCantBeReverted,551		/// Collection settings not allowing items transferring552		TransferNotAllowed,553		/// Account token limit exceeded per collection554		AccountTokenLimitExceeded,555		/// Collection token limit exceeded556		CollectionTokenLimitExceeded,557		/// Metadata flag frozen558		MetadataFlagFrozen,559560		/// Item does not exist561		TokenNotFound,562		/// Item is balance not enough563		TokenValueTooLow,564		/// Requested value is more than the approved565		ApprovedValueTooLow,566		/// Tried to approve more than owned567		CantApproveMoreThanOwned,568569		/// Can't transfer tokens to ethereum zero address570		AddressIsZero,571572		/// The operation is not supported573		UnsupportedOperation,574575		/// Insufficient funds to perform an action576		NotSufficientFounds,577578		/// User does not satisfy the nesting rule579		UserIsNotAllowedToNest,580		/// Only tokens from specific collections may nest tokens under this one581		SourceCollectionIsNotAllowedToNest,582583		/// Tried to store more data than allowed in collection field584		CollectionFieldSizeExceeded,585586		/// Tried to store more property data than allowed587		NoSpaceForProperty,588589		/// Tried to store more property keys than allowed590		PropertyLimitReached,591592		/// Property key is too long593		PropertyKeyIsTooLong,594595		/// Only ASCII letters, digits, and symbols `_`, `-`, and `.` are allowed596		InvalidCharacterInPropertyKey,597598		/// Empty property keys are forbidden599		EmptyPropertyKey,600601		/// Tried to access an external collection with an internal API602		CollectionIsExternal,603604		/// Tried to access an internal collection with an external API605		CollectionIsInternal,606	}607608	/// Storage of the count of created collections. Essentially contains the last collection ID.609	#[pallet::storage]610	pub type CreatedCollectionCount<T> = StorageValue<Value = CollectionId, QueryKind = ValueQuery>;611612	/// Storage of the count of deleted collections.613	#[pallet::storage]614	pub type DestroyedCollectionCount<T> =615		StorageValue<Value = CollectionId, QueryKind = ValueQuery>;616617	/// Storage of collection info.618	#[pallet::storage]619	pub type CollectionById<T> = StorageMap<620		Hasher = Blake2_128Concat,621		Key = CollectionId,622		Value = Collection<<T as frame_system::Config>::AccountId>,623		QueryKind = OptionQuery,624	>;625626	/// Storage of collection properties.627	#[pallet::storage]628	#[pallet::getter(fn collection_properties)]629	pub type CollectionProperties<T> = StorageMap<630		Hasher = Blake2_128Concat,631		Key = CollectionId,632		Value = Properties,633		QueryKind = ValueQuery,634		OnEmpty = up_data_structs::CollectionProperties,635	>;636637	/// Storage of token property permissions of a collection.638	#[pallet::storage]639	#[pallet::getter(fn property_permissions)]640	pub type CollectionPropertyPermissions<T> = StorageMap<641		Hasher = Blake2_128Concat,642		Key = CollectionId,643		Value = PropertiesPermissionMap,644		QueryKind = ValueQuery,645	>;646647	/// Storage of the amount of collection admins.648	#[pallet::storage]649	pub type AdminAmount<T> = StorageMap<650		Hasher = Blake2_128Concat,651		Key = CollectionId,652		Value = u32,653		QueryKind = ValueQuery,654	>;655656	/// List of collection admins.657	#[pallet::storage]658	pub type IsAdmin<T: Config> = StorageNMap<659		Key = (660			Key<Blake2_128Concat, CollectionId>,661			Key<Blake2_128Concat, T::CrossAccountId>,662		),663		Value = bool,664		QueryKind = ValueQuery,665	>;666667	/// Allowlisted collection users.668	#[pallet::storage]669	pub type Allowlist<T: Config> = StorageNMap<670		Key = (671			Key<Blake2_128Concat, CollectionId>,672			Key<Blake2_128Concat, T::CrossAccountId>,673		),674		Value = bool,675		QueryKind = ValueQuery,676	>;677678	/// Not used by code, exists only to provide some types to metadata.679	#[pallet::storage]680	pub type DummyStorageValue<T: Config> = StorageValue<681		Value = (682			CollectionStats,683			CollectionId,684			TokenId,685			TokenChild,686			PhantomType<(687				TokenData<T::CrossAccountId>,688				RpcCollection<T::AccountId>,689				// RMRK690				RmrkCollectionInfo<T::AccountId>,691				RmrkInstanceInfo<T::AccountId>,692				RmrkResourceInfo,693				RmrkPropertyInfo,694				RmrkBaseInfo<T::AccountId>,695				RmrkPartType,696				RmrkBoundedTheme,697				RmrkNftChild,698			)>,699		),700		QueryKind = OptionQuery,701	>;702703	#[pallet::hooks]704	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {705		fn on_runtime_upgrade() -> Weight {706			StorageVersion::new(1).put::<Pallet<T>>();707708			0709		}710	}711}712713impl<T: Config> Pallet<T> {714	/// Enshure that receiver address is correct.715	///716	/// Ethereum receiver 0x0000000000000000000000000000000000000000 is reserved, and shouldn't own tokens.717	pub fn ensure_correct_receiver(receiver: &T::CrossAccountId) -> DispatchResult {718		ensure!(719			&T::CrossAccountId::from_eth(H160([0; 20])) != receiver,720			<Error<T>>::AddressIsZero721		);722		Ok(())723	}724725	/// Get a vector of collection admins.726	pub fn adminlist(collection: CollectionId) -> Vec<T::CrossAccountId> {727		<IsAdmin<T>>::iter_prefix((collection,))728			.map(|(a, _)| a)729			.collect()730	}731732	/// Get a vector of users allowed to mint tokens.733	pub fn allowlist(collection: CollectionId) -> Vec<T::CrossAccountId> {734		<Allowlist<T>>::iter_prefix((collection,))735			.map(|(a, _)| a)736			.collect()737	}738739	/// Is `user` allowed to mint token in `collection`.740	pub fn allowed(collection: CollectionId, user: T::CrossAccountId) -> bool {741		<Allowlist<T>>::get((collection, user))742	}743744	/// Get statistics of collections.745	pub fn collection_stats() -> CollectionStats {746		let created = <CreatedCollectionCount<T>>::get();747		let destroyed = <DestroyedCollectionCount<T>>::get();748		CollectionStats {749			created: created.0,750			destroyed: destroyed.0,751			alive: created.0 - destroyed.0,752		}753	}754755	/// Get the effective limits for the collection.756	pub fn effective_collection_limits(collection: CollectionId) -> Option<CollectionLimits> {757		let collection = <CollectionById<T>>::get(collection)?;758		let limits = collection.limits;759		let effective_limits = CollectionLimits {760			account_token_ownership_limit: Some(limits.account_token_ownership_limit()),761			sponsored_data_size: Some(limits.sponsored_data_size()),762			sponsored_data_rate_limit: Some(763				limits764					.sponsored_data_rate_limit765					.unwrap_or(SponsoringRateLimit::SponsoringDisabled),766			),767			token_limit: Some(limits.token_limit()),768			sponsor_transfer_timeout: Some(limits.sponsor_transfer_timeout(769				match collection.mode {770					CollectionMode::NFT => NFT_SPONSOR_TRANSFER_TIMEOUT,771					CollectionMode::Fungible(_) => FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,772					CollectionMode::ReFungible => REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,773				},774			)),775			sponsor_approve_timeout: Some(limits.sponsor_approve_timeout()),776			owner_can_transfer: Some(limits.owner_can_transfer()),777			owner_can_destroy: Some(limits.owner_can_destroy()),778			transfers_enabled: Some(limits.transfers_enabled()),779		};780781		Some(effective_limits)782	}783784	/// Returns information about the `collection` adapted for rpc.785	pub fn rpc_collection(collection: CollectionId) -> Option<RpcCollection<T::AccountId>> {786		let Collection {787			name,788			description,789			owner,790			mode,791			token_prefix,792			sponsorship,793			limits,794			permissions,795			external_collection,796		} = <CollectionById<T>>::get(collection)?;797798		let token_property_permissions = <CollectionPropertyPermissions<T>>::get(collection)799			.into_iter()800			.map(|(key, permission)| PropertyKeyPermission { key, permission })801			.collect();802803		let properties = <CollectionProperties<T>>::get(collection)804			.into_iter()805			.map(|(key, value)| Property { key, value })806			.collect();807808		let permissions = CollectionPermissions {809			access: Some(permissions.access()),810			mint_mode: Some(permissions.mint_mode()),811			nesting: Some(permissions.nesting().clone()),812		};813814		Some(RpcCollection {815			name: name.into_inner(),816			description: description.into_inner(),817			owner,818			mode,819			token_prefix: token_prefix.into_inner(),820			sponsorship,821			limits,822			permissions,823			token_property_permissions,824			properties,825			read_only: external_collection,826		})827	}828}829830macro_rules! limit_default {831	($old:ident, $new:ident, $($field:ident $(($arg:expr))? => $check:expr),* $(,)?) => {{832		$(833			if let Some($new) = $new.$field {834				let $old = $old.$field($($arg)?);835				let _ = $new;836				let _ = $old;837				$check838			} else {839				$new.$field = $old.$field840			}841		)*842	}};843}844macro_rules! limit_default_clone {845	($old:ident, $new:ident, $($field:ident $(($arg:expr))? => $check:expr),* $(,)?) => {{846		$(847			if let Some($new) = $new.$field.clone() {848				let $old = $old.$field($($arg)?);849				let _ = $new;850				let _ = $old;851				$check852			} else {853				$new.$field = $old.$field.clone()854			}855		)*856	}};857}858859impl<T: Config> Pallet<T> {860	/// Create new collection.861	///862	/// * `owner` - The owner of the collection.863	/// * `data` - Description of the created collection.864	/// * `is_external` - Marks that collection managet by not "Unique network".865	pub fn init_collection(866		owner: T::CrossAccountId,867		data: CreateCollectionData<T::AccountId>,868		is_external: bool,869	) -> Result<CollectionId, DispatchError> {870		{871			ensure!(872				data.token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH as usize,873				Error::<T>::CollectionTokenPrefixLimitExceeded874			);875		}876877		let created_count = <CreatedCollectionCount<T>>::get()878			.0879			.checked_add(1)880			.ok_or(ArithmeticError::Overflow)?;881		let destroyed_count = <DestroyedCollectionCount<T>>::get().0;882		let id = CollectionId(created_count);883884		// bound Total number of collections885		ensure!(886			created_count - destroyed_count <= COLLECTION_NUMBER_LIMIT,887			<Error<T>>::TotalCollectionsLimitExceeded888		);889890		// =========891892		let collection = Collection {893			owner: owner.as_sub().clone(),894			name: data.name,895			mode: data.mode.clone(),896			description: data.description,897			token_prefix: data.token_prefix,898			sponsorship: data899				.pending_sponsor900				.map(SponsorshipState::Unconfirmed)901				.unwrap_or_default(),902			limits: data903				.limits904				.map(|limits| Self::clamp_limits(data.mode.clone(), &Default::default(), limits))905				.unwrap_or_else(|| Ok(CollectionLimits::default()))?,906			permissions: data907				.permissions908				.map(|permissions| {909					Self::clamp_permissions(data.mode.clone(), &Default::default(), permissions)910				})911				.unwrap_or_else(|| Ok(CollectionPermissions::default()))?,912			external_collection: is_external,913		};914915		let mut collection_properties = up_data_structs::CollectionProperties::get();916		collection_properties917			.try_set_from_iter(data.properties.into_iter())918			.map_err(<Error<T>>::from)?;919920		CollectionProperties::<T>::insert(id, collection_properties);921922		let mut token_props_permissions = PropertiesPermissionMap::new();923		token_props_permissions924			.try_set_from_iter(data.token_property_permissions.into_iter())925			.map_err(<Error<T>>::from)?;926927		CollectionPropertyPermissions::<T>::insert(id, token_props_permissions);928929		// Take a (non-refundable) deposit of collection creation930		{931			let mut imbalance =932				<<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();933			imbalance.subsume(934				<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(935					&T::TreasuryAccountId::get(),936					T::CollectionCreationPrice::get(),937				),938			);939			<T as Config>::Currency::settle(940				owner.as_sub(),941				imbalance,942				WithdrawReasons::TRANSFER,943				ExistenceRequirement::KeepAlive,944			)945			.map_err(|_| Error::<T>::NotSufficientFounds)?;946		}947948		<CreatedCollectionCount<T>>::put(created_count);949		<Pallet<T>>::deposit_event(Event::CollectionCreated(950			id,951			data.mode.id(),952			owner.as_sub().clone(),953		));954		<PalletEvm<T>>::deposit_log(955			erc::CollectionHelpersEvents::CollectionCreated {956				owner: *owner.as_eth(),957				collection_id: eth::collection_id_to_address(id),958			}959			.to_log(T::ContractAddress::get()),960		);961		<CollectionById<T>>::insert(id, collection);962		Ok(id)963	}964965	/// Destroy collection.966	///967	/// * `collection` - Collection handler.968	/// * `sender` - The owner or administrator of the collection.969	pub fn destroy_collection(970		collection: CollectionHandle<T>,971		sender: &T::CrossAccountId,972	) -> DispatchResult {973		ensure!(974			collection.limits.owner_can_destroy(),975			<Error<T>>::NoPermission,976		);977		collection.check_is_owner(sender)?;978979		let destroyed_collections = <DestroyedCollectionCount<T>>::get()980			.0981			.checked_add(1)982			.ok_or(ArithmeticError::Overflow)?;983984		// =========985986		<DestroyedCollectionCount<T>>::put(destroyed_collections);987		<CollectionById<T>>::remove(collection.id);988		<AdminAmount<T>>::remove(collection.id);989		let _ = <IsAdmin<T>>::clear_prefix((collection.id,), u32::MAX, None);990		let _ = <Allowlist<T>>::clear_prefix((collection.id,), u32::MAX, None);991		<CollectionProperties<T>>::remove(collection.id);992993		<Pallet<T>>::deposit_event(Event::CollectionDestroyed(collection.id));994		Ok(())995	}996997	/// Set collection property.998	///999	/// * `collection` - Collection handler.1000	/// * `sender` - The owner or administrator of the collection.1001	/// * `property` - The property to set.1002	pub fn set_collection_property(1003		collection: &CollectionHandle<T>,1004		sender: &T::CrossAccountId,1005		property: Property,1006	) -> DispatchResult {1007		collection.check_is_owner_or_admin(sender)?;10081009		CollectionProperties::<T>::try_mutate(collection.id, |properties| {1010			let property = property.clone();1011			properties.try_set(property.key, property.value)1012		})1013		.map_err(<Error<T>>::from)?;10141015		Self::deposit_event(Event::CollectionPropertySet(collection.id, property.key));10161017		Ok(())1018	}10191020	/// Set scouped collection property.1021	///1022	/// * `collection_id` - ID of the collection for which the property is being set.1023	/// * `scope` - Property scope.1024	/// * `property` - The property to set.1025	pub fn set_scoped_collection_property(1026		collection_id: CollectionId,1027		scope: PropertyScope,1028		property: Property,1029	) -> DispatchResult {1030		CollectionProperties::<T>::try_mutate(collection_id, |properties| {1031			properties.try_scoped_set(scope, property.key, property.value)1032		})1033		.map_err(<Error<T>>::from)?;10341035		Ok(())1036	}10371038	/// Set scouped collection properties.1039	///1040	/// * `collection_id` - ID of the collection for which the properties is being set.1041	/// * `scope` - Property scope.1042	/// * `properties` - The properties to set.1043	pub fn set_scoped_collection_properties(1044		collection_id: CollectionId,1045		scope: PropertyScope,1046		properties: impl Iterator<Item = Property>,1047	) -> DispatchResult {1048		CollectionProperties::<T>::try_mutate(collection_id, |stored_properties| {1049			stored_properties.try_scoped_set_from_iter(scope, properties)1050		})1051		.map_err(<Error<T>>::from)?;10521053		Ok(())1054	}10551056	/// Set collection properties.1057	///1058	/// * `collection` - Collection handler.1059	/// * `sender` - The owner or administrator of the collection.1060	/// * `properties` - The properties to set.1061	#[transactional]1062	pub fn set_collection_properties(1063		collection: &CollectionHandle<T>,1064		sender: &T::CrossAccountId,1065		properties: Vec<Property>,1066	) -> DispatchResult {1067		for property in properties {1068			Self::set_collection_property(collection, sender, property)?;1069		}10701071		Ok(())1072	}10731074	/// Delete collection property.1075	///1076	/// * `collection` - Collection handler.1077	/// * `sender` - The owner or administrator of the collection.1078	/// * `property` - The property to delete.1079	pub fn delete_collection_property(1080		collection: &CollectionHandle<T>,1081		sender: &T::CrossAccountId,1082		property_key: PropertyKey,1083	) -> DispatchResult {1084		collection.check_is_owner_or_admin(sender)?;10851086		CollectionProperties::<T>::try_mutate(collection.id, |properties| {1087			properties.remove(&property_key)1088		})1089		.map_err(<Error<T>>::from)?;10901091		Self::deposit_event(Event::CollectionPropertyDeleted(1092			collection.id,1093			property_key,1094		));10951096		Ok(())1097	}10981099	/// Delete collection properties.1100	///1101	/// * `collection` - Collection handler.1102	/// * `sender` - The owner or administrator of the collection.1103	/// * `properties` - The properties to delete.1104	#[transactional]1105	pub fn delete_collection_properties(1106		collection: &CollectionHandle<T>,1107		sender: &T::CrossAccountId,1108		property_keys: Vec<PropertyKey>,1109	) -> DispatchResult {1110		for key in property_keys {1111			Self::delete_collection_property(collection, sender, key)?;1112		}11131114		Ok(())1115	}11161117	/// Set collection propetry permission without any checks.1118	///1119	/// Used for migrations.1120	///1121	/// * `collection` - Collection handler.1122	/// * `property_permissions` - Property permissions.1123	pub fn set_property_permission_unchecked(1124		collection: CollectionId,1125		property_permission: PropertyKeyPermission,1126	) -> DispatchResult {1127		<CollectionPropertyPermissions<T>>::try_mutate(collection, |permissions| {1128			permissions.try_set(property_permission.key, property_permission.permission)1129		})1130		.map_err(<Error<T>>::from)?;1131		Ok(())1132	}11331134	/// Set collection property permission.1135	///1136	/// * `collection` - Collection handler.1137	/// * `sender` - The owner or administrator of the collection.1138	/// * `property_permission` - Property permission.1139	pub fn set_property_permission(1140		collection: &CollectionHandle<T>,1141		sender: &T::CrossAccountId,1142		property_permission: PropertyKeyPermission,1143	) -> DispatchResult {1144		Self::set_scoped_property_permission(1145			collection,1146			sender,1147			PropertyScope::None,1148			property_permission,1149		)1150	}11511152	/// Set collection property permission with scope.1153	///1154	/// * `collection` - Collection handler.1155	/// * `sender` - The owner or administrator of the collection.1156	/// * `scope` - Property scope.1157	/// * `property_permission` - Property permission.1158	pub fn set_scoped_property_permission(1159		collection: &CollectionHandle<T>,1160		sender: &T::CrossAccountId,1161		scope: PropertyScope,1162		property_permission: PropertyKeyPermission,1163	) -> DispatchResult {1164		collection.check_is_owner_or_admin(sender)?;11651166		let all_permissions = CollectionPropertyPermissions::<T>::get(collection.id);1167		let current_permission = all_permissions.get(&property_permission.key);1168		if matches![1169			current_permission,1170			Some(PropertyPermission { mutable: false, .. })1171		] {1172			return Err(<Error<T>>::NoPermission.into());1173		}11741175		CollectionPropertyPermissions::<T>::try_mutate(collection.id, |permissions| {1176			let property_permission = property_permission.clone();1177			permissions.try_scoped_set(1178				scope,1179				property_permission.key,1180				property_permission.permission,1181			)1182		})1183		.map_err(<Error<T>>::from)?;11841185		Self::deposit_event(Event::PropertyPermissionSet(1186			collection.id,1187			property_permission.key,1188		));11891190		Ok(())1191	}11921193	/// Set token property permission.1194	///1195	/// * `collection` - Collection handler.1196	/// * `sender` - The owner or administrator of the collection.1197	/// * `property_permissions` - Property permissions.1198	#[transactional]1199	pub fn set_token_property_permissions(1200		collection: &CollectionHandle<T>,1201		sender: &T::CrossAccountId,1202		property_permissions: Vec<PropertyKeyPermission>,1203	) -> DispatchResult {1204		Self::set_scoped_token_property_permissions(1205			collection,1206			sender,1207			PropertyScope::None,1208			property_permissions,1209		)1210	}12111212	/// Set token property permission with scope.1213	///1214	/// * `collection` - Collection handler.1215	/// * `sender` - The owner or administrator of the collection.1216	/// * `scope` - Property scope.1217	/// * `property_permissions` - Property permissions.1218	#[transactional]1219	pub fn set_scoped_token_property_permissions(1220		collection: &CollectionHandle<T>,1221		sender: &T::CrossAccountId,1222		scope: PropertyScope,1223		property_permissions: Vec<PropertyKeyPermission>,1224	) -> DispatchResult {1225		for prop_pemission in property_permissions {1226			Self::set_scoped_property_permission(collection, sender, scope, prop_pemission)?;1227		}12281229		Ok(())1230	}12311232	/// Get collection property.1233	pub fn get_collection_property(1234		collection_id: CollectionId,1235		key: &PropertyKey,1236	) -> Option<PropertyValue> {1237		Self::collection_properties(collection_id).get(key).cloned()1238	}12391240	/// Convert byte vector to property key vector.1241	pub fn bytes_keys_to_property_keys(1242		keys: Vec<Vec<u8>>,1243	) -> Result<Vec<PropertyKey>, DispatchError> {1244		keys.into_iter()1245			.map(|key| -> Result<PropertyKey, DispatchError> {1246				key.try_into()1247					.map_err(|_| <Error<T>>::PropertyKeyIsTooLong.into())1248			})1249			.collect::<Result<Vec<PropertyKey>, DispatchError>>()1250	}12511252	/// Get properties according to given keys.1253	pub fn filter_collection_properties(1254		collection_id: CollectionId,1255		keys: Option<Vec<PropertyKey>>,1256	) -> Result<Vec<Property>, DispatchError> {1257		let properties = Self::collection_properties(collection_id);12581259		let properties = keys1260			.map(|keys| {1261				keys.into_iter()1262					.filter_map(|key| {1263						properties.get(&key).map(|value| Property {1264							key,1265							value: value.clone(),1266						})1267					})1268					.collect()1269			})1270			.unwrap_or_else(|| {1271				properties1272					.into_iter()1273					.map(|(key, value)| Property { key, value })1274					.collect()1275			});12761277		Ok(properties)1278	}12791280	/// Get property permissions according to given keys.1281	pub fn filter_property_permissions(1282		collection_id: CollectionId,1283		keys: Option<Vec<PropertyKey>>,1284	) -> Result<Vec<PropertyKeyPermission>, DispatchError> {1285		let permissions = Self::property_permissions(collection_id);12861287		let key_permissions = keys1288			.map(|keys| {1289				keys.into_iter()1290					.filter_map(|key| {1291						permissions1292							.get(&key)1293							.map(|permission| PropertyKeyPermission {1294								key,1295								permission: permission.clone(),1296							})1297					})1298					.collect()1299			})1300			.unwrap_or_else(|| {1301				permissions1302					.into_iter()1303					.map(|(key, permission)| PropertyKeyPermission { key, permission })1304					.collect()1305			});13061307		Ok(key_permissions)1308	}13091310	/// Toggle `user` participation in the `collection`'s allow list.1311	/// #### Store read/writes1312	/// 1 writes1313	pub fn toggle_allowlist(1314		collection: &CollectionHandle<T>,1315		sender: &T::CrossAccountId,1316		user: &T::CrossAccountId,1317		allowed: bool,1318	) -> DispatchResult {1319		collection.check_is_owner_or_admin(sender)?;13201321		// =========13221323		if allowed {1324			<Allowlist<T>>::insert((collection.id, user), true);1325		} else {1326			<Allowlist<T>>::remove((collection.id, user));1327		}13281329		Ok(())1330	}13311332	/// Toggle `user` participation in the `collection`'s admin list.1333	/// #### Store read/writes1334	/// 2 writes1335	pub fn toggle_admin(1336		collection: &CollectionHandle<T>,1337		sender: &T::CrossAccountId,1338		user: &T::CrossAccountId,1339		admin: bool,1340	) -> DispatchResult {1341		collection.check_is_owner(sender)?;13421343		let was_admin = <IsAdmin<T>>::get((collection.id, user));1344		if was_admin == admin {1345			return Ok(());1346		}1347		let amount = <AdminAmount<T>>::get(collection.id);13481349		if admin {1350			let amount = amount1351				.checked_add(1)1352				.ok_or(<Error<T>>::CollectionAdminCountExceeded)?;1353			ensure!(1354				amount <= Self::collection_admins_limit(),1355				<Error<T>>::CollectionAdminCountExceeded,1356			);13571358			// =========13591360			<AdminAmount<T>>::insert(collection.id, amount);1361			<IsAdmin<T>>::insert((collection.id, user), true);1362		} else {1363			<AdminAmount<T>>::insert(collection.id, amount.saturating_sub(1));1364			<IsAdmin<T>>::remove((collection.id, user));1365		}13661367		Ok(())1368	}13691370	/// Merge set fields from `new_limit` to `old_limit`.1371	pub fn clamp_limits(1372		mode: CollectionMode,1373		old_limit: &CollectionLimits,1374		mut new_limit: CollectionLimits,1375	) -> Result<CollectionLimits, DispatchError> {1376		let limits = old_limit;1377		limit_default!(old_limit, new_limit,1378			account_token_ownership_limit => ensure!(1379				new_limit <= MAX_TOKEN_OWNERSHIP,1380				<Error<T>>::CollectionLimitBoundsExceeded,1381			),1382			sponsored_data_size => ensure!(1383				new_limit <= CUSTOM_DATA_LIMIT,1384				<Error<T>>::CollectionLimitBoundsExceeded,1385			),13861387			sponsored_data_rate_limit => {},1388			token_limit => ensure!(1389				old_limit >= new_limit && new_limit > 0,1390				<Error<T>>::CollectionTokenLimitExceeded1391			),13921393			sponsor_transfer_timeout(match mode {1394				CollectionMode::NFT => NFT_SPONSOR_TRANSFER_TIMEOUT,1395				CollectionMode::Fungible(_) => FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,1396				CollectionMode::ReFungible => REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,1397			}) => ensure!(1398				new_limit <= MAX_SPONSOR_TIMEOUT,1399				<Error<T>>::CollectionLimitBoundsExceeded,1400			),1401			sponsor_approve_timeout => {},1402			owner_can_transfer => ensure!(1403				!limits.owner_can_transfer_instaled() ||1404				old_limit || !new_limit,1405				<Error<T>>::OwnerPermissionsCantBeReverted,1406			),1407			owner_can_destroy => ensure!(1408				old_limit || !new_limit,1409				<Error<T>>::OwnerPermissionsCantBeReverted,1410			),1411			transfers_enabled => {},1412		);1413		Ok(new_limit)1414	}14151416	/// Merge set fields from `new_permission` to `old_permission`.1417	pub fn clamp_permissions(1418		_mode: CollectionMode,1419		old_permission: &CollectionPermissions,1420		mut new_permission: CollectionPermissions,1421	) -> Result<CollectionPermissions, DispatchError> {1422		limit_default_clone!(old_permission, new_permission,1423			access => {},1424			mint_mode => {},1425			nesting => { /* todo check for permissive, if only it gets out of benchmarks */ },1426		);1427		Ok(new_permission)1428	}1429}14301431/// Indicates unsupported methods by returning [Error::UnsupportedOperation].1432#[macro_export]1433macro_rules! unsupported {1434	($runtime:path) => {1435		Err($crate::Error::<$runtime>::UnsupportedOperation.into())1436	};1437}14381439/// Return weights for various worst-case operations.1440pub trait CommonWeightInfo<CrossAccountId> {1441	/// Weight of item creation.1442	fn create_item() -> Weight;14431444	/// Weight of items creation.1445	fn create_multiple_items(amount: &[CreateItemData]) -> Weight;14461447	/// Weight of items creation.1448	fn create_multiple_items_ex(cost: &CreateItemExData<CrossAccountId>) -> Weight;14491450	/// The weight of the burning item.1451	fn burn_item() -> Weight;14521453	/// Property setting weight.1454	///1455	/// * `amount`- The number of properties to set.1456	fn set_collection_properties(amount: u32) -> Weight;14571458	/// Collection property deletion weight.1459	///1460	/// * `amount`- The number of properties to set.1461	fn delete_collection_properties(amount: u32) -> Weight;14621463	/// Token property setting weight.1464	///1465	/// * `amount`- The number of properties to set.1466	fn set_token_properties(amount: u32) -> Weight;14671468	/// Token property deletion weight.1469	///1470	/// * `amount`- The number of properties to delete.1471	fn delete_token_properties(amount: u32) -> Weight;14721473	/// Token property permissions set weight.1474	///1475	/// * `amount`- The number of property permissions to set.1476	fn set_token_property_permissions(amount: u32) -> Weight;14771478	/// Transfer price of the token or its parts.1479	fn transfer() -> Weight;14801481	/// The price of setting the permission of the operation from another user.1482	fn approve() -> Weight;14831484	/// Transfer price from another user.1485	fn transfer_from() -> Weight;14861487	/// The price of burning a token from another user.1488	fn burn_from() -> Weight;14891490	/// Differs from burn_item in case of Fungible and Refungible, as it should burn1491	/// whole users's balance.1492	///1493	/// This method shouldn't be used directly, as it doesn't count breadth price, use [burn_recursively](CommonWeightInfo::burn_recursively) instead1494	fn burn_recursively_self_raw() -> Weight;14951496	/// Cost of iterating over `amount` children while burning, without counting child burning itself.1497	///1498	/// This method shouldn't be used directly, as it doesn't count depth price, use [burn_recursively](CommonWeightInfo::burn_recursively) instead1499	fn burn_recursively_breadth_raw(amount: u32) -> Weight;15001501	/// The price of recursive burning a token.1502	///1503	/// `max_selfs` - The maximum burning weight of the token itself.1504	/// `max_breadth` - The maximum number of nested tokens to burn.1505	fn burn_recursively(max_selfs: u32, max_breadth: u32) -> Weight {1506		Self::burn_recursively_self_raw()1507			.saturating_mul(max_selfs.max(1) as u64)1508			.saturating_add(Self::burn_recursively_breadth_raw(max_breadth))1509	}15101511	/// The price of retrieving token owner1512	fn token_owner() -> Weight;1513}15141515/// Weight info extension trait for refungible pallet.1516pub trait RefungibleExtensionsWeightInfo {1517	/// Weight of token repartition.1518	fn repartition() -> Weight;1519}15201521/// Common collection operations.1522///1523/// It wraps methods in Fungible, Nonfungible and Refungible pallets1524/// and adds weight info.1525pub trait CommonCollectionOperations<T: Config> {1526	/// Create token.1527	///1528	/// * `sender` - The user who mint the token and pays for the transaction.1529	/// * `to` - The user who will own the token.1530	/// * `data` - Token data.1531	/// * `nesting_budget` - A budget that can be spent on nesting tokens.1532	fn create_item(1533		&self,1534		sender: T::CrossAccountId,1535		to: T::CrossAccountId,1536		data: CreateItemData,1537		nesting_budget: &dyn Budget,1538	) -> DispatchResultWithPostInfo;15391540	/// Create multiple tokens.1541	///1542	/// * `sender` - The user who mint the token and pays for the transaction.1543	/// * `to` - The user who will own the token.1544	/// * `data` - Token data.1545	/// * `nesting_budget` - A budget that can be spent on nesting tokens.1546	fn create_multiple_items(1547		&self,1548		sender: T::CrossAccountId,1549		to: T::CrossAccountId,1550		data: Vec<CreateItemData>,1551		nesting_budget: &dyn Budget,1552	) -> DispatchResultWithPostInfo;15531554	/// Create multiple tokens.1555	///1556	/// * `sender` - The user who mint the token and pays for the transaction.1557	/// * `to` - The user who will own the token.1558	/// * `data` - Token data.1559	/// * `nesting_budget` - A budget that can be spent on nesting tokens.1560	fn create_multiple_items_ex(1561		&self,1562		sender: T::CrossAccountId,1563		data: CreateItemExData<T::CrossAccountId>,1564		nesting_budget: &dyn Budget,1565	) -> DispatchResultWithPostInfo;15661567	/// Burn token.1568	///1569	/// * `sender` - The user who owns the token.1570	/// * `token` - Token id that will burned.1571	/// * `amount` - The number of parts of the token that will be burned.1572	fn burn_item(1573		&self,1574		sender: T::CrossAccountId,1575		token: TokenId,1576		amount: u128,1577	) -> DispatchResultWithPostInfo;15781579	/// Burn token and all nested tokens recursievly.1580	///1581	/// * `sender` - The user who owns the token.1582	/// * `token` - Token id that will burned.1583	/// * `self_budget` - The budget that can be spent on burning tokens.1584	/// * `breadth_budget` - The budget that can be spent on burning nested tokens.1585	fn burn_item_recursively(1586		&self,1587		sender: T::CrossAccountId,1588		token: TokenId,1589		self_budget: &dyn Budget,1590		breadth_budget: &dyn Budget,1591	) -> DispatchResultWithPostInfo;15921593	/// Set collection properties.1594	///1595	/// * `sender` - Must be either the owner of the collection or its admin.1596	/// * `properties` - Properties to be set.1597	fn set_collection_properties(1598		&self,1599		sender: T::CrossAccountId,1600		properties: Vec<Property>,1601	) -> DispatchResultWithPostInfo;16021603	/// Delete collection properties.1604	///1605	/// * `sender` - Must be either the owner of the collection or its admin.1606	/// * `properties` - The properties to be removed.1607	fn delete_collection_properties(1608		&self,1609		sender: &T::CrossAccountId,1610		property_keys: Vec<PropertyKey>,1611	) -> DispatchResultWithPostInfo;16121613	/// Set token properties.1614	///1615	/// The appropriate [`PropertyPermission`] for the token property1616	/// must be set with [`Self::set_token_property_permissions`].1617	///1618	/// * `sender` - Must be either the owner of the token or its admin.1619	/// * `token_id` - The token for which the properties are being set.1620	/// * `properties` - Properties to be set.1621	/// * `budget` - Budget for setting properties.1622	fn set_token_properties(1623		&self,1624		sender: T::CrossAccountId,1625		token_id: TokenId,1626		properties: Vec<Property>,1627		budget: &dyn Budget,1628	) -> DispatchResultWithPostInfo;16291630	/// Remove token properties.1631	///1632	/// The appropriate [`PropertyPermission`] for the token property1633	/// must be set with [`Self::set_token_property_permissions`].1634	///1635	/// * `sender` - Must be either the owner of the token or its admin.1636	/// * `token_id` - The token for which the properties are being remove.1637	/// * `property_keys` - Keys to remove corresponding properties.1638	/// * `budget` - Budget for removing properties.1639	fn delete_token_properties(1640		&self,1641		sender: T::CrossAccountId,1642		token_id: TokenId,1643		property_keys: Vec<PropertyKey>,1644		budget: &dyn Budget,1645	) -> DispatchResultWithPostInfo;16461647	/// Set token property permissions.1648	///1649	/// * `sender` - Must be either the owner of the token or its admin.1650	/// * `token_id` - The token for which the properties are being set.1651	/// * `property_permissions` - Property permissions to be set.1652	/// * `budget` - Budget for setting properties.1653	fn set_token_property_permissions(1654		&self,1655		sender: &T::CrossAccountId,1656		property_permissions: Vec<PropertyKeyPermission>,1657	) -> DispatchResultWithPostInfo;16581659	/// Transfer amount of token pieces.1660	///1661	/// * `sender` - Donor user.1662	/// * `to` - Recepient user.1663	/// * `token` - The token of which parts are being sent.1664	/// * `amount` - The number of parts of the token that will be transferred.1665	/// * `budget` - The maximum budget that can be spent on the transfer.1666	fn transfer(1667		&self,1668		sender: T::CrossAccountId,1669		to: T::CrossAccountId,1670		token: TokenId,1671		amount: u128,1672		budget: &dyn Budget,1673	) -> DispatchResultWithPostInfo;16741675	/// Grant access to another account to transfer parts of the token owned by the calling user via [Self::transfer_from].1676	///1677	/// * `sender` - The user who grants access to the token.1678	/// * `spender` - The user to whom the rights are granted.1679	/// * `token` - The token to which access is granted.1680	/// * `amount` - The amount of pieces that another user can dispose of.1681	fn approve(1682		&self,1683		sender: T::CrossAccountId,1684		spender: T::CrossAccountId,1685		token: TokenId,1686		amount: u128,1687	) -> DispatchResultWithPostInfo;16881689	/// Send 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	/// * `to` - Recepient user.1696	/// * `token` - The token of which parts are being sent.1697	/// * `amount` - The number of parts of the token that will be transferred.1698	/// * `budget` - The maximum budget that can be spent on the transfer.1699	fn transfer_from(1700		&self,1701		sender: T::CrossAccountId,1702		from: T::CrossAccountId,1703		to: T::CrossAccountId,1704		token: TokenId,1705		amount: u128,1706		budget: &dyn Budget,1707	) -> DispatchResultWithPostInfo;17081709	/// Burn parts of a token owned by another user.1710	///1711	/// Before calling this method, you must grant rights to the calling user via [`Self::approve`].1712	///1713	/// * `sender` - The user who must have access to the token (see [`Self::approve`]).1714	/// * `from` - The user who owns the token.1715	/// * `token` - The token of which parts are being sent.1716	/// * `amount` - The number of parts of the token that will be transferred.1717	/// * `budget` - The maximum budget that can be spent on the burn.1718	fn burn_from(1719		&self,1720		sender: T::CrossAccountId,1721		from: T::CrossAccountId,1722		token: TokenId,1723		amount: u128,1724		budget: &dyn Budget,1725	) -> DispatchResultWithPostInfo;17261727	/// Check permission to nest token.1728	///1729	/// * `sender` - The user who initiated the check.1730	/// * `from` - The token that is checked for embedding.1731	/// * `under` - Token under which to check.1732	/// * `budget` - The maximum budget that can be spent on the check.1733	fn check_nesting(1734		&self,1735		sender: T::CrossAccountId,1736		from: (CollectionId, TokenId),1737		under: TokenId,1738		budget: &dyn Budget,1739	) -> DispatchResult;17401741	/// Nest one token into another.1742	///1743	/// * `under` - Token holder.1744	/// * `to_nest` - Nested token.1745	fn nest(&self, under: TokenId, to_nest: (CollectionId, TokenId));17461747	/// Unnest token.1748	///1749	/// * `under` - Token holder.1750	/// * `to_nest` - Token to unnest.1751	fn unnest(&self, under: TokenId, to_nest: (CollectionId, TokenId));17521753	/// Get all user tokens.1754	///1755	/// * `account` - Account for which you need to get tokens.1756	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId>;17571758	/// Get all the tokens in the collection.1759	fn collection_tokens(&self) -> Vec<TokenId>;17601761	/// Check if the token exists.1762	///1763	/// * `token` - Id token to check.1764	fn token_exists(&self, token: TokenId) -> bool;17651766	/// Get the id of the last minted token.1767	fn last_token_id(&self) -> TokenId;17681769	/// Get the owner of the token.1770	///1771	/// * `token` - The token for which you need to find out the owner.1772	fn token_owner(&self, token: TokenId) -> Option<T::CrossAccountId>;17731774	/// Returns 10 tokens owners in no particular order.1775	///1776	/// * `token` - The token for which you need to find out the owners.1777	fn token_owners(&self, token: TokenId) -> Vec<T::CrossAccountId>;17781779	/// Get the value of the token property by key.1780	///1781	/// * `token` - Token with the property to get.1782	/// * `key` - Property name.1783	fn token_property(&self, token_id: TokenId, key: &PropertyKey) -> Option<PropertyValue>;17841785	/// Get a set of token properties by key vector.1786	///1787	/// * `token` - Token with the property to get.1788	/// * `keys` - Vector of property keys. If this parameter is [None](sp_std::result::Result),1789	/// then all properties are returned.1790	fn token_properties(&self, token: TokenId, keys: Option<Vec<PropertyKey>>) -> Vec<Property>;17911792	/// Amount of unique collection tokens1793	fn total_supply(&self) -> u32;17941795	/// Amount of different tokens account has.1796	///1797	/// * `account` - The account for which need to get the balance.1798	fn account_balance(&self, account: T::CrossAccountId) -> u32;17991800	/// Amount of specific token account have.1801	fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128;18021803	/// Amount of token pieces1804	fn total_pieces(&self, token: TokenId) -> Option<u128>;18051806	/// Get the number of parts of the token that a trusted user can manage.1807	///1808	/// * `sender` - Trusted user.1809	/// * `spender` - Owner of the token.1810	/// * `token` - The token for which to get the value.1811	fn allowance(1812		&self,1813		sender: T::CrossAccountId,1814		spender: T::CrossAccountId,1815		token: TokenId,1816	) -> u128;18171818	/// Get extension for RFT collection.1819	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>>;1820}18211822/// Extension for RFT collection.1823pub trait RefungibleExtensions<T>1824where1825	T: Config,1826{1827	/// Change the number of parts of the token.1828	///1829	/// When the value changes down, this function is equivalent to burning parts of the token.1830	///1831	/// * `sender` - The user calling the repartition operation. Must be the owner of the token.1832	/// * `token` - The token for which you want to change the number of parts.1833	/// * `amount` - The new value of the parts of the token.1834	fn repartition(1835		&self,1836		sender: &T::CrossAccountId,1837		token: TokenId,1838		amount: u128,1839	) -> DispatchResultWithPostInfo;1840}18411842/// Merge [`DispatchResult`] with [`Weight`] into [`DispatchResultWithPostInfo`].1843///1844/// Used for [`CommonCollectionOperations`] implementations and flexible enough to do so.1845pub fn with_weight(res: DispatchResult, weight: Weight) -> DispatchResultWithPostInfo {1846	let post_info = PostDispatchInfo {1847		actual_weight: Some(weight),1848		pays_fee: Pays::Yes,1849	};1850	match res {1851		Ok(()) => Ok(post_info),1852		Err(error) => Err(DispatchErrorWithPostInfo { post_info, error }),1853	}1854}18551856impl<T: Config> From<PropertiesError> for Error<T> {1857	fn from(error: PropertiesError) -> Self {1858		match error {1859			PropertiesError::NoSpaceForProperty => Self::NoSpaceForProperty,1860			PropertiesError::PropertyLimitReached => Self::PropertyLimitReached,1861			PropertiesError::InvalidCharacterInPropertyKey => Self::InvalidCharacterInPropertyKey,1862			PropertiesError::PropertyKeyIsTooLong => Self::PropertyKeyIsTooLong,1863			PropertiesError::EmptyPropertyKey => Self::EmptyPropertyKey,1864		}1865	}1866}