git.delta.rocks / unique-network / refs/commits / 81e4404a75c5

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::{57	ops::{Deref, DerefMut},58	slice::from_ref,59};60use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};61use sp_std::vec::Vec;62use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};63use evm_coder::ToLog;64use frame_support::{65	dispatch::{DispatchErrorWithPostInfo, DispatchResultWithPostInfo, Weight, PostDispatchInfo},66	ensure,67	traits::{Imbalance, Get, Currency, WithdrawReasons, ExistenceRequirement},68	dispatch::Pays,69	transactional, fail,70};71use pallet_evm::GasWeightMapping;72use up_data_structs::{73	AccessMode, COLLECTION_NUMBER_LIMIT, Collection, RpcCollection, CollectionFlags,74	RpcCollectionFlags, CollectionId, CreateItemData, MAX_TOKEN_PREFIX_LENGTH,75	COLLECTION_ADMINS_LIMIT, TokenId, TokenChild, CollectionStats, MAX_TOKEN_OWNERSHIP,76	CollectionMode, NFT_SPONSOR_TRANSFER_TIMEOUT, FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,77	REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT, MAX_SPONSOR_TIMEOUT, CUSTOM_DATA_LIMIT, CollectionLimits,78	CreateCollectionData, SponsorshipState, CreateItemExData, SponsoringRateLimit, budget::Budget,79	PhantomType, Property, CollectionProperties as CollectionPropertiesT, TokenProperties,80	PropertiesPermissionMap, PropertyKey, PropertyValue, PropertyPermission, PropertiesError,81	TokenOwnerError, PropertyKeyPermission, TokenData, TrySetProperty, PropertyScope,82	CollectionPermissions,83};84use up_pov_estimate_rpc::PovInfo;8586pub use pallet::*;87use sp_core::H160;88use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};8990#[cfg(feature = "runtime-benchmarks")]91pub mod benchmarking;92pub mod dispatch;93pub mod erc;94pub mod eth;95#[allow(missing_docs)]96pub mod weights;9798/// Weight info.99pub type SelfWeightOf<T> = <T as Config>::WeightInfo;100101/// Collection handle contains information about collection data and id.102/// Also provides functionality to count consumed gas.103///104/// CollectionHandle is used as a generic wrapper for collections of all types.105/// It allows to perform common operations and queries on any collection type,106/// both completely general for all, as well as their respective implementations of [`CommonCollectionOperations`].107#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]108pub struct CollectionHandle<T: Config> {109	/// Collection id110	pub id: CollectionId,111	collection: Collection<T::AccountId>,112	/// Substrate recorder for counting consumed gas113	pub recorder: SubstrateRecorder<T>,114}115116impl<T: Config> WithRecorder<T> for CollectionHandle<T> {117	fn recorder(&self) -> &SubstrateRecorder<T> {118		&self.recorder119	}120	fn into_recorder(self) -> SubstrateRecorder<T> {121		self.recorder122	}123}124125impl<T: Config> CollectionHandle<T> {126	/// Same as [CollectionHandle::new] but with an explicit gas limit.127	pub fn new_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {128		<CollectionById<T>>::get(id).map(|collection| Self {129			id,130			collection,131			recorder: SubstrateRecorder::new(gas_limit),132		})133	}134135	/// Same as [CollectionHandle::new] but with an existed [`SubstrateRecorder`].136	pub fn new_with_recorder(id: CollectionId, recorder: SubstrateRecorder<T>) -> Option<Self> {137		<CollectionById<T>>::get(id).map(|collection| Self {138			id,139			collection,140			recorder,141		})142	}143144	/// Retrives collection data from storage and creates collection handle with default parameters.145	/// If collection not found return `None`146	pub fn new(id: CollectionId) -> Option<Self> {147		Self::new_with_gas_limit(id, u64::MAX)148	}149150	/// Same as [`CollectionHandle::new`] but if collection not found [CollectionNotFound](Error::CollectionNotFound) returned.151	pub fn try_get(id: CollectionId) -> Result<Self, DispatchError> {152		Ok(Self::new(id).ok_or(<Error<T>>::CollectionNotFound)?)153	}154155	/// Consume gas for reading.156	pub fn consume_store_reads(157		&self,158		reads: u64,159	) -> pallet_evm_coder_substrate::execution::Result<()> {160		self.recorder161			.consume_gas(T::GasWeightMapping::weight_to_gas(Weight::from_parts(162				<T as frame_system::Config>::DbWeight::get()163					.read164					.saturating_mul(reads),165				// TODO: measure proof166				0,167			)))168	}169170	/// Consume gas for writing.171	pub fn consume_store_writes(172		&self,173		writes: u64,174	) -> pallet_evm_coder_substrate::execution::Result<()> {175		self.recorder176			.consume_gas(T::GasWeightMapping::weight_to_gas(Weight::from_parts(177				<T as frame_system::Config>::DbWeight::get()178					.write179					.saturating_mul(writes),180				// TODO: measure proof181				0,182			)))183	}184185	/// Consume gas for reading and writing.186	pub fn consume_store_reads_and_writes(187		&self,188		reads: u64,189		writes: u64,190	) -> pallet_evm_coder_substrate::execution::Result<()> {191		let weight = <T as frame_system::Config>::DbWeight::get();192		let reads = weight.read.saturating_mul(reads);193		let writes = weight.read.saturating_mul(writes);194		self.recorder195			.consume_gas(T::GasWeightMapping::weight_to_gas(Weight::from_parts(196				reads.saturating_add(writes),197				// TODO: measure proof198				0,199			)))200	}201202	/// Save collection to storage.203	pub fn save(&self) -> DispatchResult {204		<CollectionById<T>>::insert(self.id, &self.collection);205		Ok(())206	}207208	/// Set collection sponsor.209	///210	/// Unique collections allows sponsoring for certain actions.211	/// This method allows you to set the sponsor of the collection.212	/// In order for sponsorship to become active, it must be confirmed through [`Self::confirm_sponsorship`].213	pub fn set_sponsor(214		&mut self,215		sender: &T::CrossAccountId,216		sponsor: T::AccountId,217	) -> DispatchResult {218		self.check_is_internal()?;219		self.check_is_owner_or_admin(sender)?;220221		self.collection.sponsorship = SponsorshipState::Unconfirmed(sponsor.clone());222223		<Pallet<T>>::deposit_event(Event::<T>::CollectionSponsorSet(self.id, sponsor));224		<PalletEvm<T>>::deposit_log(225			erc::CollectionHelpersEvents::CollectionChanged {226				collection_id: eth::collection_id_to_address(self.id),227			}228			.to_log(T::ContractAddress::get()),229		);230231		self.save()232	}233234	/// Force set `sponsor`.235	///236	/// Differs from [`set_sponsor`][`Self::set_sponsor`] in that confirmation237	/// from the `sponsor` is not required.238	///239	/// # Arguments240	///241	/// * `sender`: Caller's account.242	/// * `sponsor`: ID of the account of the sponsor-to-be.243	pub fn force_set_sponsor(&mut self, sponsor: T::AccountId) -> DispatchResult {244		self.check_is_internal()?;245246		self.collection.sponsorship = SponsorshipState::Confirmed(sponsor.clone());247248		<Pallet<T>>::deposit_event(Event::<T>::CollectionSponsorSet(self.id, sponsor.clone()));249		<Pallet<T>>::deposit_event(Event::<T>::SponsorshipConfirmed(self.id, sponsor));250		<PalletEvm<T>>::deposit_log(251			erc::CollectionHelpersEvents::CollectionChanged {252				collection_id: eth::collection_id_to_address(self.id),253			}254			.to_log(T::ContractAddress::get()),255		);256257		self.save()258	}259260	/// Confirm sponsorship261	///262	/// In order for the sponsorship to become active, the user set as the sponsor must confirm their participation.263	/// Before confirming sponsorship, the user must be specified as the sponsor of the collection via [`Self::set_sponsor`].264	pub fn confirm_sponsorship(&mut self, sender: &T::AccountId) -> DispatchResult {265		self.check_is_internal()?;266		ensure!(267			self.collection.sponsorship.pending_sponsor() == Some(sender),268			Error::<T>::ConfirmSponsorshipFail269		);270271		self.collection.sponsorship = SponsorshipState::Confirmed(sender.clone());272273		<Pallet<T>>::deposit_event(Event::<T>::SponsorshipConfirmed(self.id, sender.clone()));274		<PalletEvm<T>>::deposit_log(275			erc::CollectionHelpersEvents::CollectionChanged {276				collection_id: eth::collection_id_to_address(self.id),277			}278			.to_log(T::ContractAddress::get()),279		);280281		self.save()282	}283284	/// Remove collection sponsor.285	pub fn remove_sponsor(&mut self, sender: &T::CrossAccountId) -> DispatchResult {286		self.check_is_internal()?;287		self.check_is_owner_or_admin(sender)?;288289		self.collection.sponsorship = SponsorshipState::Disabled;290291		<Pallet<T>>::deposit_event(Event::<T>::CollectionSponsorRemoved(self.id));292		<PalletEvm<T>>::deposit_log(293			erc::CollectionHelpersEvents::CollectionChanged {294				collection_id: eth::collection_id_to_address(self.id),295			}296			.to_log(T::ContractAddress::get()),297		);298		self.save()299	}300301	/// Force remove `sponsor`.302	///303	/// Differs from `remove_sponsor` in that304	/// it doesn't require consent from the `owner` of the collection.305	pub fn force_remove_sponsor(&mut self) -> DispatchResult {306		self.check_is_internal()?;307308		self.collection.sponsorship = SponsorshipState::Disabled;309310		<Pallet<T>>::deposit_event(Event::<T>::CollectionSponsorRemoved(self.id));311		<PalletEvm<T>>::deposit_log(312			erc::CollectionHelpersEvents::CollectionChanged {313				collection_id: eth::collection_id_to_address(self.id),314			}315			.to_log(T::ContractAddress::get()),316		);317		self.save()318	}319320	/// Checks that the collection was created with, and must be operated upon through **Unique API**.321	/// Now check only the `external` flag and if it's **true**, then return [`Error::CollectionIsExternal`] error.322	pub fn check_is_internal(&self) -> DispatchResult {323		if self.flags.external {324			return Err(<Error<T>>::CollectionIsExternal)?;325		}326327		Ok(())328	}329330	/// Checks that the collection was created with, and must be operated upon through an **assimilated API**.331	/// Now check only the `external` flag and if it's **false**, then return [`Error::CollectionIsInternal`] error.332	pub fn check_is_external(&self) -> DispatchResult {333		if !self.flags.external {334			return Err(<Error<T>>::CollectionIsInternal)?;335		}336337		Ok(())338	}339}340341impl<T: Config> Deref for CollectionHandle<T> {342	type Target = Collection<T::AccountId>;343344	fn deref(&self) -> &Self::Target {345		&self.collection346	}347}348349impl<T: Config> DerefMut for CollectionHandle<T> {350	fn deref_mut(&mut self) -> &mut Self::Target {351		&mut self.collection352	}353}354355impl<T: Config> CollectionHandle<T> {356	/// Checks if the `user` is the owner of the collection.357	pub fn check_is_owner(&self, user: &T::CrossAccountId) -> DispatchResult {358		ensure!(*user.as_sub() == self.owner, <Error<T>>::NoPermission);359		Ok(())360	}361362	/// Returns **true** if the `user` is the owner or administrator of the collection.363	pub fn is_owner_or_admin(&self, user: &T::CrossAccountId) -> bool {364		*user.as_sub() == self.owner || <IsAdmin<T>>::get((self.id, user))365	}366367	/// Checks if the `user` is the owner or administrator of the collection.368	pub fn check_is_owner_or_admin(&self, user: &T::CrossAccountId) -> DispatchResult {369		ensure!(self.is_owner_or_admin(user), <Error<T>>::NoPermission);370		Ok(())371	}372373	/// Returns **true** if374	/// * the `user`is a collection owner or admin375	/// * the collection limits allow the owner/admins to transfer/burn any collection token376	pub fn ignores_token_restrictions(&self, user: &T::CrossAccountId) -> bool {377		self.limits.owner_can_transfer() && self.is_owner_or_admin(user)378	}379380	/// Return **true** if `user` does not have enough token parts, and he can ignore such restrictions.381	pub fn ignores_owned_amount(&self, user: &T::CrossAccountId) -> bool {382		self.limits.owner_can_transfer() && self.is_owner_or_admin(user)383	}384385	/// Checks if the user is in the allow list. If not [Error::AddressNotInAllowlist] returns.386	pub fn check_allowlist(&self, user: &T::CrossAccountId) -> DispatchResult {387		ensure!(388			<Allowlist<T>>::get((self.id, user)),389			<Error<T>>::AddressNotInAllowlist390		);391		Ok(())392	}393394	/// Changes collection owner to another account395	/// #### Store read/writes396	/// 1 writes397	pub fn change_owner(398		&mut self,399		caller: T::CrossAccountId,400		new_owner: T::CrossAccountId,401	) -> DispatchResult {402		self.check_is_internal()?;403		self.check_is_owner(&caller)?;404		self.collection.owner = new_owner.as_sub().clone();405406		<Pallet<T>>::deposit_event(Event::<T>::CollectionOwnerChanged(407			self.id,408			new_owner.as_sub().clone(),409		));410		<PalletEvm<T>>::deposit_log(411			erc::CollectionHelpersEvents::CollectionChanged {412				collection_id: eth::collection_id_to_address(self.id),413			}414			.to_log(T::ContractAddress::get()),415		);416417		self.save()418	}419}420421#[frame_support::pallet]422pub mod pallet {423	use core::marker::PhantomData;424425	use super::*;426	use dispatch::CollectionDispatch;427	use frame_support::{Blake2_128Concat, pallet_prelude::*, storage::Key, traits::StorageVersion};428	use frame_support::traits::Currency;429	use up_data_structs::{TokenId, mapping::TokenAddressMapping};430	use scale_info::TypeInfo;431	use weights::WeightInfo;432433	#[pallet::config]434	pub trait Config:435		frame_system::Config + pallet_evm_coder_substrate::Config + pallet_evm::Config + TypeInfo436	{437		/// Weight information for functions of this pallet.438		type WeightInfo: WeightInfo;439440		/// Events compatible with [`frame_system::Config::Event`].441		type RuntimeEvent: IsType<<Self as frame_system::Config>::RuntimeEvent> + From<Event<Self>>;442443		/// Handler of accounts and payment.444		type Currency: Currency<Self::AccountId>;445446		/// Set price to create a collection.447		#[pallet::constant]448		type CollectionCreationPrice: Get<449			<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,450		>;451452		/// Dispatcher of operations on collections.453		type CollectionDispatch: CollectionDispatch<Self>;454455		/// Account which holds the chain's treasury.456		type TreasuryAccountId: Get<Self::AccountId>;457458		/// Address under which the CollectionHelper contract would be available.459		#[pallet::constant]460		type ContractAddress: Get<H160>;461462		/// Mapper for token addresses to Ethereum addresses.463		type EvmTokenAddressMapping: TokenAddressMapping<H160>;464465		/// Mapper for token addresses to [`CrossAccountId`].466		type CrossTokenAddressMapping: TokenAddressMapping<Self::CrossAccountId>;467	}468469	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);470471	#[pallet::pallet]472	#[pallet::storage_version(STORAGE_VERSION)]473	pub struct Pallet<T>(_);474475	#[pallet::extra_constants]476	impl<T: Config> Pallet<T> {477		/// Maximum admins per collection.478		pub fn collection_admins_limit() -> u32 {479			COLLECTION_ADMINS_LIMIT480		}481	}482483	#[pallet::genesis_config]484	pub struct GenesisConfig<T>(PhantomData<T>);485486	#[cfg(feature = "std")]487	impl<T: Config> Default for GenesisConfig<T> {488		fn default() -> Self {489			Self(Default::default())490		}491	}492493	#[pallet::genesis_build]494	impl<T: Config> GenesisBuild<T> for GenesisConfig<T> {495		fn build(&self) {496			StorageVersion::new(1).put::<Pallet<T>>();497		}498	}499	impl<T: Config> Pallet<T> {500		/// Helper function that handles deposit events501		pub fn deposit_event(event: Event<T>) {502			let event = <T as Config>::RuntimeEvent::from(event);503			let event = event.into();504			<frame_system::Pallet<T>>::deposit_event(event)505		}506	}507508	#[pallet::event]509	pub enum Event<T: Config> {510		/// New collection was created511		CollectionCreated(512			/// Globally unique identifier of newly created collection.513			CollectionId,514			/// [`CollectionMode`] converted into _u8_.515			u8,516			/// Collection owner.517			T::AccountId,518		),519520		/// New collection was destroyed521		CollectionDestroyed(522			/// Globally unique identifier of collection.523			CollectionId,524		),525526		/// New item was created.527		ItemCreated(528			/// Id of the collection where item was created.529			CollectionId,530			/// Id of an item. Unique within the collection.531			TokenId,532			/// Owner of newly created item533			T::CrossAccountId,534			/// Always 1 for NFT535			u128,536		),537538		/// Collection item was burned.539		ItemDestroyed(540			/// Id of the collection where item was destroyed.541			CollectionId,542			/// Identifier of burned NFT.543			TokenId,544			/// Which user has destroyed its tokens.545			T::CrossAccountId,546			/// Amount of token pieces destroed. Always 1 for NFT.547			u128,548		),549550		/// Item was transferred551		Transfer(552			/// Id of collection to which item is belong.553			CollectionId,554			/// Id of an item.555			TokenId,556			/// Original owner of item.557			T::CrossAccountId,558			/// New owner of item.559			T::CrossAccountId,560			/// Amount of token pieces transfered. Always 1 for NFT.561			u128,562		),563564		/// Amount pieces of token owned by `sender` was approved for `spender`.565		Approved(566			/// Id of collection to which item is belong.567			CollectionId,568			/// Id of an item.569			TokenId,570			/// Original owner of item.571			T::CrossAccountId,572			/// Id for which the approval was granted.573			T::CrossAccountId,574			/// Amount of token pieces transfered. Always 1 for NFT.575			u128,576		),577578		/// A `sender` approves operations on all owned tokens for `spender`.579		ApprovedForAll(580			/// Id of collection to which item is belong.581			CollectionId,582			/// Owner of a wallet.583			T::CrossAccountId,584			/// Id for which operator status was granted or rewoked.585			T::CrossAccountId,586			/// Is operator status granted or revoked?587			bool,588		),589590		/// The colletion property has been added or edited.591		CollectionPropertySet(592			/// Id of collection to which property has been set.593			CollectionId,594			/// The property that was set.595			PropertyKey,596		),597598		/// The property has been deleted.599		CollectionPropertyDeleted(600			/// Id of collection to which property has been deleted.601			CollectionId,602			/// The property that was deleted.603			PropertyKey,604		),605606		/// The token property has been added or edited.607		TokenPropertySet(608			/// Identifier of the collection whose token has the property set.609			CollectionId,610			/// The token for which the property was set.611			TokenId,612			/// The property that was set.613			PropertyKey,614		),615616		/// The token property has been deleted.617		TokenPropertyDeleted(618			/// Identifier of the collection whose token has the property deleted.619			CollectionId,620			/// The token for which the property was deleted.621			TokenId,622			/// The property that was deleted.623			PropertyKey,624		),625626		/// The token property permission of a collection has been set.627		PropertyPermissionSet(628			/// ID of collection to which property permission has been set.629			CollectionId,630			/// The property permission that was set.631			PropertyKey,632		),633634		/// Address was added to the allow list.635		AllowListAddressAdded(636			/// ID of the affected collection.637			CollectionId,638			/// Address of the added account.639			T::CrossAccountId,640		),641642		/// Address was removed from the allow list.643		AllowListAddressRemoved(644			/// ID of the affected collection.645			CollectionId,646			/// Address of the removed account.647			T::CrossAccountId,648		),649650		/// Collection admin was added.651		CollectionAdminAdded(652			/// ID of the affected collection.653			CollectionId,654			/// Admin address.655			T::CrossAccountId,656		),657658		/// Collection admin was removed.659		CollectionAdminRemoved(660			/// ID of the affected collection.661			CollectionId,662			/// Removed admin address.663			T::CrossAccountId,664		),665666		/// Collection limits were set.667		CollectionLimitSet(668			/// ID of the affected collection.669			CollectionId,670		),671672		/// Collection owned was changed.673		CollectionOwnerChanged(674			/// ID of the affected collection.675			CollectionId,676			/// New owner address.677			T::AccountId,678		),679680		/// Collection permissions were set.681		CollectionPermissionSet(682			/// ID of the affected collection.683			CollectionId,684		),685686		/// Collection sponsor was set.687		CollectionSponsorSet(688			/// ID of the affected collection.689			CollectionId,690			/// New sponsor address.691			T::AccountId,692		),693694		/// New sponsor was confirm.695		SponsorshipConfirmed(696			/// ID of the affected collection.697			CollectionId,698			/// New sponsor address.699			T::AccountId,700		),701702		/// Collection sponsor was removed.703		CollectionSponsorRemoved(704			/// ID of the affected collection.705			CollectionId,706		),707	}708709	#[pallet::error]710	pub enum Error<T> {711		/// This collection does not exist.712		CollectionNotFound,713		/// Sender parameter and item owner must be equal.714		MustBeTokenOwner,715		/// No permission to perform action716		NoPermission,717		/// Destroying only empty collections is allowed718		CantDestroyNotEmptyCollection,719		/// Collection is not in mint mode.720		PublicMintingNotAllowed,721		/// Address is not in allow list.722		AddressNotInAllowlist,723724		/// Collection name can not be longer than 63 char.725		CollectionNameLimitExceeded,726		/// Collection description can not be longer than 255 char.727		CollectionDescriptionLimitExceeded,728		/// Token prefix can not be longer than 15 char.729		CollectionTokenPrefixLimitExceeded,730		/// Total collections bound exceeded.731		TotalCollectionsLimitExceeded,732		/// Exceeded max admin count733		CollectionAdminCountExceeded,734		/// Collection limit bounds per collection exceeded735		CollectionLimitBoundsExceeded,736		/// Tried to enable permissions which are only permitted to be disabled737		OwnerPermissionsCantBeReverted,738		/// Collection settings not allowing items transferring739		TransferNotAllowed,740		/// Account token limit exceeded per collection741		AccountTokenLimitExceeded,742		/// Collection token limit exceeded743		CollectionTokenLimitExceeded,744		/// Metadata flag frozen745		MetadataFlagFrozen,746747		/// Item does not exist748		TokenNotFound,749		/// Item is balance not enough750		TokenValueTooLow,751		/// Requested value is more than the approved752		ApprovedValueTooLow,753		/// Tried to approve more than owned754		CantApproveMoreThanOwned,755		/// Only spending from eth mirror could be approved756		AddressIsNotEthMirror,757758		/// Can't transfer tokens to ethereum zero address759		AddressIsZero,760761		/// The operation is not supported762		UnsupportedOperation,763764		/// Insufficient funds to perform an action765		NotSufficientFounds,766767		/// User does not satisfy the nesting rule768		UserIsNotAllowedToNest,769		/// Only tokens from specific collections may nest tokens under this one770		SourceCollectionIsNotAllowedToNest,771772		/// Tried to store more data than allowed in collection field773		CollectionFieldSizeExceeded,774775		/// Tried to store more property data than allowed776		NoSpaceForProperty,777778		/// Tried to store more property keys than allowed779		PropertyLimitReached,780781		/// Property key is too long782		PropertyKeyIsTooLong,783784		/// Only ASCII letters, digits, and symbols `_`, `-`, and `.` are allowed785		InvalidCharacterInPropertyKey,786787		/// Empty property keys are forbidden788		EmptyPropertyKey,789790		/// Tried to access an external collection with an internal API791		CollectionIsExternal,792793		/// Tried to access an internal collection with an external API794		CollectionIsInternal,795796		/// This address is not set as sponsor, use setCollectionSponsor first.797		ConfirmSponsorshipFail,798799		/// The user is not an administrator.800		UserIsNotCollectionAdmin,801	}802803	/// Storage of the count of created collections. Essentially contains the last collection ID.804	#[pallet::storage]805	pub type CreatedCollectionCount<T> = StorageValue<Value = CollectionId, QueryKind = ValueQuery>;806807	/// Storage of the count of deleted collections.808	#[pallet::storage]809	pub type DestroyedCollectionCount<T> =810		StorageValue<Value = CollectionId, QueryKind = ValueQuery>;811812	/// Storage of collection info.813	#[pallet::storage]814	pub type CollectionById<T> = StorageMap<815		Hasher = Blake2_128Concat,816		Key = CollectionId,817		Value = Collection<<T as frame_system::Config>::AccountId>,818		QueryKind = OptionQuery,819	>;820821	/// Storage of collection properties.822	#[pallet::storage]823	#[pallet::getter(fn collection_properties)]824	pub type CollectionProperties<T> = StorageMap<825		Hasher = Blake2_128Concat,826		Key = CollectionId,827		Value = CollectionPropertiesT,828		QueryKind = ValueQuery,829	>;830831	/// Storage of token property permissions of a collection.832	#[pallet::storage]833	#[pallet::getter(fn property_permissions)]834	pub type CollectionPropertyPermissions<T> = StorageMap<835		Hasher = Blake2_128Concat,836		Key = CollectionId,837		Value = PropertiesPermissionMap,838		QueryKind = ValueQuery,839	>;840841	/// Storage of the amount of collection admins.842	#[pallet::storage]843	pub type AdminAmount<T> = StorageMap<844		Hasher = Blake2_128Concat,845		Key = CollectionId,846		Value = u32,847		QueryKind = ValueQuery,848	>;849850	/// List of collection admins.851	#[pallet::storage]852	pub type IsAdmin<T: Config> = StorageNMap<853		Key = (854			Key<Blake2_128Concat, CollectionId>,855			Key<Blake2_128Concat, T::CrossAccountId>,856		),857		Value = bool,858		QueryKind = ValueQuery,859	>;860861	/// Allowlisted collection users.862	#[pallet::storage]863	pub type Allowlist<T: Config> = StorageNMap<864		Key = (865			Key<Blake2_128Concat, CollectionId>,866			Key<Blake2_128Concat, T::CrossAccountId>,867		),868		Value = bool,869		QueryKind = ValueQuery,870	>;871872	/// Not used by code, exists only to provide some types to metadata.873	#[pallet::storage]874	pub type DummyStorageValue<T: Config> = StorageValue<875		Value = (876			CollectionStats,877			CollectionId,878			TokenId,879			TokenChild,880			PhantomType<(881				TokenData<T::CrossAccountId>,882				RpcCollection<T::AccountId>,883				// PoV Estimate Info884				PovInfo,885			)>,886		),887		QueryKind = OptionQuery,888	>;889}890891impl<T: Config> Pallet<T> {892	/// Enshure that receiver address is correct.893	///894	/// Ethereum receiver 0x0000000000000000000000000000000000000000 is reserved, and shouldn't own tokens.895	pub fn ensure_correct_receiver(receiver: &T::CrossAccountId) -> DispatchResult {896		ensure!(897			&T::CrossAccountId::from_eth(H160([0; 20])) != receiver,898			<Error<T>>::AddressIsZero899		);900		Ok(())901	}902903	/// Get a vector of collection admins.904	pub fn adminlist(collection: CollectionId) -> Vec<T::CrossAccountId> {905		<IsAdmin<T>>::iter_prefix((collection,))906			.map(|(a, _)| a)907			.collect()908	}909910	/// Get a vector of users allowed to mint tokens.911	pub fn allowlist(collection: CollectionId) -> Vec<T::CrossAccountId> {912		<Allowlist<T>>::iter_prefix((collection,))913			.map(|(a, _)| a)914			.collect()915	}916917	/// Is `user` allowed to mint token in `collection`.918	pub fn allowed(collection: CollectionId, user: T::CrossAccountId) -> bool {919		<Allowlist<T>>::get((collection, user))920	}921922	/// Get statistics of collections.923	pub fn collection_stats() -> CollectionStats {924		let created = <CreatedCollectionCount<T>>::get();925		let destroyed = <DestroyedCollectionCount<T>>::get();926		CollectionStats {927			created: created.0,928			destroyed: destroyed.0,929			alive: created.0 - destroyed.0,930		}931	}932933	/// Get the effective limits for the collection.934	pub fn effective_collection_limits(collection: CollectionId) -> Option<CollectionLimits> {935		let collection = <CollectionById<T>>::get(collection)?;936		let limits = collection.limits;937		let effective_limits = CollectionLimits {938			account_token_ownership_limit: Some(limits.account_token_ownership_limit()),939			sponsored_data_size: Some(limits.sponsored_data_size()),940			sponsored_data_rate_limit: Some(941				limits942					.sponsored_data_rate_limit943					.unwrap_or(SponsoringRateLimit::SponsoringDisabled),944			),945			token_limit: Some(limits.token_limit()),946			sponsor_transfer_timeout: Some(limits.sponsor_transfer_timeout(947				match collection.mode {948					CollectionMode::NFT => NFT_SPONSOR_TRANSFER_TIMEOUT,949					CollectionMode::Fungible(_) => FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,950					CollectionMode::ReFungible => REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,951				},952			)),953			sponsor_approve_timeout: Some(limits.sponsor_approve_timeout()),954			owner_can_transfer: Some(limits.owner_can_transfer()),955			owner_can_destroy: Some(limits.owner_can_destroy()),956			transfers_enabled: Some(limits.transfers_enabled()),957		};958959		Some(effective_limits)960	}961962	/// Returns information about the `collection` adapted for rpc.963	pub fn rpc_collection(collection: CollectionId) -> Option<RpcCollection<T::AccountId>> {964		let Collection {965			name,966			description,967			owner,968			mode,969			token_prefix,970			sponsorship,971			limits,972			permissions,973			flags,974		} = <CollectionById<T>>::get(collection)?;975976		let token_property_permissions = <CollectionPropertyPermissions<T>>::get(collection)977			.into_iter()978			.map(|(key, permission)| PropertyKeyPermission { key, permission })979			.collect();980981		let properties = <CollectionProperties<T>>::get(collection)982			.into_iter()983			.map(|(key, value)| Property { key, value })984			.collect();985986		let permissions = CollectionPermissions {987			access: Some(permissions.access()),988			mint_mode: Some(permissions.mint_mode()),989			nesting: Some(permissions.nesting().clone()),990		};991992		Some(RpcCollection {993			name: name.into_inner(),994			description: description.into_inner(),995			owner,996			mode,997			token_prefix: token_prefix.into_inner(),998			sponsorship,999			limits,1000			permissions,1001			token_property_permissions,1002			properties,1003			read_only: flags.external,10041005			flags: RpcCollectionFlags {1006				foreign: flags.foreign,1007				erc721metadata: flags.erc721metadata,1008			},1009		})1010	}1011}10121013macro_rules! limit_default {1014	($old:ident, $new:ident, $($field:ident $(($arg:expr))? => $check:expr),* $(,)?) => {{1015		$(1016			if let Some($new) = $new.$field {1017				let $old = $old.$field($($arg)?);1018				let _ = $new;1019				let _ = $old;1020				$check1021			} else {1022				$new.$field = $old.$field1023			}1024		)*1025	}};1026}1027macro_rules! limit_default_clone {1028	($old:ident, $new:ident, $($field:ident $(($arg:expr))? => $check:expr),* $(,)?) => {{1029		$(1030			if let Some($new) = $new.$field.clone() {1031				let $old = $old.$field($($arg)?);1032				let _ = $new;1033				let _ = $old;1034				$check1035			} else {1036				$new.$field = $old.$field.clone()1037			}1038		)*1039	}};1040}10411042impl<T: Config> Pallet<T> {1043	/// Create new collection.1044	///1045	/// * `owner` - The owner of the collection.1046	/// * `data` - Description of the created collection.1047	/// * `flags` - Extra flags to store.1048	pub fn init_collection(1049		owner: T::CrossAccountId,1050		payer: T::CrossAccountId,1051		data: CreateCollectionData<T::AccountId>,1052		flags: CollectionFlags,1053	) -> Result<CollectionId, DispatchError> {1054		{1055			ensure!(1056				data.token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH as usize,1057				Error::<T>::CollectionTokenPrefixLimitExceeded1058			);1059		}10601061		let created_count = <CreatedCollectionCount<T>>::get()1062			.01063			.checked_add(1)1064			.ok_or(ArithmeticError::Overflow)?;1065		let destroyed_count = <DestroyedCollectionCount<T>>::get().0;1066		let id = CollectionId(created_count);10671068		// bound Total number of collections1069		ensure!(1070			created_count - destroyed_count <= COLLECTION_NUMBER_LIMIT,1071			<Error<T>>::TotalCollectionsLimitExceeded1072		);10731074		// =========10751076		let collection = Collection {1077			owner: owner.as_sub().clone(),1078			name: data.name,1079			mode: data.mode.clone(),1080			description: data.description,1081			token_prefix: data.token_prefix,1082			sponsorship: data1083				.pending_sponsor1084				.map(SponsorshipState::Unconfirmed)1085				.unwrap_or_default(),1086			limits: data1087				.limits1088				.map(|limits| Self::clamp_limits(data.mode.clone(), &Default::default(), limits))1089				.unwrap_or_else(|| Ok(CollectionLimits::default()))?,1090			permissions: data1091				.permissions1092				.map(|permissions| {1093					Self::clamp_permissions(data.mode.clone(), &Default::default(), permissions)1094				})1095				.unwrap_or_else(|| Ok(CollectionPermissions::default()))?,1096			flags,1097		};10981099		let mut collection_properties = CollectionPropertiesT::new();1100		collection_properties1101			.try_set_from_iter(data.properties.into_iter())1102			.map_err(<Error<T>>::from)?;11031104		CollectionProperties::<T>::insert(id, collection_properties);11051106		let mut token_props_permissions = PropertiesPermissionMap::new();1107		token_props_permissions1108			.try_set_from_iter(data.token_property_permissions.into_iter())1109			.map_err(<Error<T>>::from)?;11101111		CollectionPropertyPermissions::<T>::insert(id, token_props_permissions);11121113		// Take a (non-refundable) deposit of collection creation1114		{1115			let mut imbalance =1116				<<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();1117			imbalance.subsume(1118				<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(1119					&T::TreasuryAccountId::get(),1120					T::CollectionCreationPrice::get(),1121				),1122			);1123			<T as Config>::Currency::settle(1124				payer.as_sub(),1125				imbalance,1126				WithdrawReasons::TRANSFER,1127				ExistenceRequirement::KeepAlive,1128			)1129			.map_err(|_| Error::<T>::NotSufficientFounds)?;1130		}11311132		<CreatedCollectionCount<T>>::put(created_count);1133		<Pallet<T>>::deposit_event(Event::CollectionCreated(1134			id,1135			data.mode.id(),1136			owner.as_sub().clone(),1137		));1138		<PalletEvm<T>>::deposit_log(1139			erc::CollectionHelpersEvents::CollectionCreated {1140				owner: *owner.as_eth(),1141				collection_id: eth::collection_id_to_address(id),1142			}1143			.to_log(T::ContractAddress::get()),1144		);1145		<CollectionById<T>>::insert(id, collection);1146		Ok(id)1147	}11481149	/// Destroy collection.1150	///1151	/// * `collection` - Collection handler.1152	/// * `sender` - The owner or administrator of the collection.1153	pub fn destroy_collection(1154		collection: CollectionHandle<T>,1155		sender: &T::CrossAccountId,1156	) -> DispatchResult {1157		ensure!(1158			collection.limits.owner_can_destroy(),1159			<Error<T>>::NoPermission,1160		);1161		collection.check_is_owner(sender)?;11621163		let destroyed_collections = <DestroyedCollectionCount<T>>::get()1164			.01165			.checked_add(1)1166			.ok_or(ArithmeticError::Overflow)?;11671168		// =========11691170		<DestroyedCollectionCount<T>>::put(destroyed_collections);1171		<CollectionById<T>>::remove(collection.id);1172		<AdminAmount<T>>::remove(collection.id);1173		let _ = <IsAdmin<T>>::clear_prefix((collection.id,), u32::MAX, None);1174		let _ = <Allowlist<T>>::clear_prefix((collection.id,), u32::MAX, None);1175		<CollectionProperties<T>>::remove(collection.id);11761177		<Pallet<T>>::deposit_event(Event::CollectionDestroyed(collection.id));11781179		<PalletEvm<T>>::deposit_log(1180			erc::CollectionHelpersEvents::CollectionDestroyed {1181				collection_id: eth::collection_id_to_address(collection.id),1182			}1183			.to_log(T::ContractAddress::get()),1184		);1185		Ok(())1186	}11871188	/// This function sets or removes a collection properties according to1189	/// `properties_updates` contents:1190	/// * sets a property under the <key> with the value provided `(<key>, Some(<value>))`1191	/// * removes a property under the <key> if the value is `None` `(<key>, None)`.1192	///1193	/// This function fires an event for each property change.1194	/// In case of an error, all the changes (including the events) will be reverted1195	/// since the function is transactional.1196	#[transactional]1197	fn modify_collection_properties(1198		collection: &CollectionHandle<T>,1199		sender: &T::CrossAccountId,1200		properties_updates: impl Iterator<Item = (PropertyKey, Option<PropertyValue>)>,1201	) -> DispatchResult {1202		collection.check_is_owner_or_admin(sender)?;12031204		let mut stored_properties = <CollectionProperties<T>>::get(collection.id);12051206		for (key, value) in properties_updates {1207			match value {1208				Some(value) => {1209					stored_properties1210						.try_set(key.clone(), value)1211						.map_err(<Error<T>>::from)?;12121213					Self::deposit_event(Event::CollectionPropertySet(collection.id, key));1214					<PalletEvm<T>>::deposit_log(1215						erc::CollectionHelpersEvents::CollectionChanged {1216							collection_id: eth::collection_id_to_address(collection.id),1217						}1218						.to_log(T::ContractAddress::get()),1219					);1220				}1221				None => {1222					stored_properties.remove(&key).map_err(<Error<T>>::from)?;12231224					Self::deposit_event(Event::CollectionPropertyDeleted(collection.id, key));1225					<PalletEvm<T>>::deposit_log(1226						erc::CollectionHelpersEvents::CollectionChanged {1227							collection_id: eth::collection_id_to_address(collection.id),1228						}1229						.to_log(T::ContractAddress::get()),1230					);1231				}1232			}1233		}12341235		<CollectionProperties<T>>::set(collection.id, stored_properties);12361237		Ok(())1238	}12391240	/// A batch operation to add, edit or remove properties for a token.1241	/// It sets or removes a token's properties according to1242	/// `properties_updates` contents:1243	/// * sets a property under the <key> with the value provided `(<key>, Some(<value>))`1244	/// * removes a property under the <key> if the value is `None` `(<key>, None)`.1245	///1246	/// - `nesting_budget`: Limit for searching parents in-depth to check ownership.1247	/// - `is_token_create`: Indicates that method is called during token initialization.1248	///   Allows to bypass ownership check.1249	///1250	/// All affected properties should have `mutable` permission1251	/// to be **deleted** or to be **set more than once**,1252	/// and the sender should have permission to edit those properties.1253	///1254	/// This function fires an event for each property change.1255	/// In case of an error, all the changes (including the events) will be reverted1256	/// since the function is transactional.1257	pub fn modify_token_properties(1258		collection: &CollectionHandle<T>,1259		sender: &T::CrossAccountId,1260		token_id: TokenId,1261		properties_updates: impl Iterator<Item = (PropertyKey, Option<PropertyValue>)>,1262		is_token_create: bool,1263		mut stored_properties: TokenProperties,1264		is_token_owner: impl Fn() -> Result<bool, DispatchError>,1265		set_token_properties: impl FnOnce(TokenProperties),1266		log: evm_coder::ethereum::Log,1267	) -> DispatchResult {1268		let is_collection_admin = collection.is_owner_or_admin(sender);1269		let permissions = Self::property_permissions(collection.id);12701271		let mut token_owner_result = None;1272		let mut is_token_owner = || -> Result<bool, DispatchError> {1273			*token_owner_result.get_or_insert_with(&is_token_owner)1274		};12751276		for (key, value) in properties_updates {1277			let permission = permissions1278				.get(&key)1279				.cloned()1280				.unwrap_or_else(PropertyPermission::none);12811282			let is_property_exists = stored_properties.get(&key).is_some();12831284			match permission {1285				PropertyPermission { mutable: false, .. } if is_property_exists => {1286					return Err(<Error<T>>::NoPermission.into());1287				}12881289				PropertyPermission {1290					collection_admin,1291					token_owner,1292					..1293				} => {1294					//TODO: investigate threats during public minting.1295					let is_token_create =1296						is_token_create && (collection_admin || token_owner) && value.is_some();1297					if !(is_token_create1298						|| (collection_admin && is_collection_admin)1299						|| (token_owner && is_token_owner()?))1300					{1301						fail!(<Error<T>>::NoPermission);1302					}1303				}1304			}13051306			match value {1307				Some(value) => {1308					stored_properties1309						.try_set(key.clone(), value)1310						.map_err(<Error<T>>::from)?;13111312					Self::deposit_event(Event::TokenPropertySet(collection.id, token_id, key));1313				}1314				None => {1315					stored_properties.remove(&key).map_err(<Error<T>>::from)?;13161317					Self::deposit_event(Event::TokenPropertyDeleted(collection.id, token_id, key));1318				}1319			}13201321			<PalletEvm<T>>::deposit_log(log.clone());1322		}13231324		set_token_properties(stored_properties);13251326		Ok(())1327	}13281329	/// Sets or unsets the approval of a given operator.1330	///1331	/// The `operator` is allowed to transfer all token pieces of the `owner` on their behalf.1332	/// - `owner`: Token owner1333	/// - `operator`: Operator1334	/// - `approve`: Should operator status be granted or revoked?1335	pub fn set_allowance_for_all(1336		collection: &CollectionHandle<T>,1337		owner: &T::CrossAccountId,1338		operator: &T::CrossAccountId,1339		approve: bool,1340		set_allowance: impl FnOnce(),1341		log: evm_coder::ethereum::Log,1342	) -> DispatchResult {1343		if collection.permissions.access() == AccessMode::AllowList {1344			collection.check_allowlist(owner)?;1345			collection.check_allowlist(operator)?;1346		}13471348		Self::ensure_correct_receiver(operator)?;13491350		set_allowance();13511352		<PalletEvm<T>>::deposit_log(log);1353		Self::deposit_event(Event::ApprovedForAll(1354			collection.id,1355			owner.clone(),1356			operator.clone(),1357			approve,1358		));1359		Ok(())1360	}13611362	/// Set collection property.1363	///1364	/// * `collection` - Collection handler.1365	/// * `sender` - The owner or administrator of the collection.1366	/// * `property` - The property to set.1367	pub fn set_collection_property(1368		collection: &CollectionHandle<T>,1369		sender: &T::CrossAccountId,1370		property: Property,1371	) -> DispatchResult {1372		Self::set_collection_properties(collection, sender, [property].into_iter())1373	}13741375	/// Set a scoped collection property, where the scope is a special prefix1376	/// prohibiting a user access to change the property directly.1377	///1378	/// * `collection_id` - ID of the collection for which the property is being set.1379	/// * `scope` - Property scope.1380	/// * `property` - The property to set.1381	pub fn set_scoped_collection_property(1382		collection_id: CollectionId,1383		scope: PropertyScope,1384		property: Property,1385	) -> DispatchResult {1386		CollectionProperties::<T>::try_mutate(collection_id, |properties| {1387			properties.try_scoped_set(scope, property.key, property.value)1388		})1389		.map_err(<Error<T>>::from)?;13901391		Ok(())1392	}13931394	/// Set scoped collection properties, where the scope is a special prefix1395	/// prohibiting a user access to change the properties directly.1396	///1397	/// * `collection_id` - ID of the collection for which the properties is being set.1398	/// * `scope` - Property scope.1399	/// * `properties` - The properties to set.1400	pub fn set_scoped_collection_properties(1401		collection_id: CollectionId,1402		scope: PropertyScope,1403		properties: impl Iterator<Item = Property>,1404	) -> DispatchResult {1405		CollectionProperties::<T>::try_mutate(collection_id, |stored_properties| {1406			stored_properties.try_scoped_set_from_iter(scope, properties)1407		})1408		.map_err(<Error<T>>::from)?;14091410		Ok(())1411	}14121413	/// Set collection properties.1414	///1415	/// * `collection` - Collection handler.1416	/// * `sender` - The owner or administrator of the collection.1417	/// * `properties` - The properties to set.1418	pub fn set_collection_properties(1419		collection: &CollectionHandle<T>,1420		sender: &T::CrossAccountId,1421		properties: impl Iterator<Item = Property>,1422	) -> DispatchResult {1423		Self::modify_collection_properties(1424			collection,1425			sender,1426			properties.map(|property| (property.key, Some(property.value))),1427		)1428	}14291430	/// Delete collection property.1431	///1432	/// * `collection` - Collection handler.1433	/// * `sender` - The owner or administrator of the collection.1434	/// * `property` - The property to delete.1435	pub fn delete_collection_property(1436		collection: &CollectionHandle<T>,1437		sender: &T::CrossAccountId,1438		property_key: PropertyKey,1439	) -> DispatchResult {1440		Self::delete_collection_properties(collection, sender, [property_key].into_iter())1441	}14421443	/// Delete collection properties.1444	///1445	/// * `collection` - Collection handler.1446	/// * `sender` - The owner or administrator of the collection.1447	/// * `properties` - The properties to delete.1448	pub fn delete_collection_properties(1449		collection: &CollectionHandle<T>,1450		sender: &T::CrossAccountId,1451		property_keys: impl Iterator<Item = PropertyKey>,1452	) -> DispatchResult {1453		Self::modify_collection_properties(collection, sender, property_keys.map(|key| (key, None)))1454	}14551456	/// Set collection propetry permission without any checks.1457	///1458	/// Used for migrations.1459	///1460	/// * `collection` - Collection handler.1461	/// * `property_permissions` - Property permissions.1462	pub fn set_property_permission_unchecked(1463		collection: CollectionId,1464		property_permission: PropertyKeyPermission,1465	) -> DispatchResult {1466		<CollectionPropertyPermissions<T>>::try_mutate(collection, |permissions| {1467			permissions.try_set(property_permission.key, property_permission.permission)1468		})1469		.map_err(<Error<T>>::from)?;1470		Ok(())1471	}14721473	/// Set collection property permission.1474	///1475	/// * `collection` - Collection handler.1476	/// * `sender` - The owner or administrator of the collection.1477	/// * `property_permission` - Property permission.1478	pub fn set_property_permission(1479		collection: &CollectionHandle<T>,1480		sender: &T::CrossAccountId,1481		property_permission: PropertyKeyPermission,1482	) -> DispatchResult {1483		Self::set_scoped_property_permission(1484			collection,1485			sender,1486			PropertyScope::None,1487			property_permission,1488		)1489	}14901491	/// Set collection property permission with scope.1492	///1493	/// * `collection` - Collection handler.1494	/// * `sender` - The owner or administrator of the collection.1495	/// * `scope` - Property scope.1496	/// * `property_permission` - Property permission.1497	pub fn set_scoped_property_permission(1498		collection: &CollectionHandle<T>,1499		sender: &T::CrossAccountId,1500		scope: PropertyScope,1501		property_permission: PropertyKeyPermission,1502	) -> DispatchResult {1503		collection.check_is_owner_or_admin(sender)?;15041505		let all_permissions = CollectionPropertyPermissions::<T>::get(collection.id);1506		let current_permission = all_permissions.get(&property_permission.key);1507		if matches![1508			current_permission,1509			Some(PropertyPermission { mutable: false, .. })1510		] {1511			return Err(<Error<T>>::NoPermission.into());1512		}15131514		CollectionPropertyPermissions::<T>::try_mutate(collection.id, |permissions| {1515			let property_permission = property_permission.clone();1516			permissions.try_scoped_set(1517				scope,1518				property_permission.key,1519				property_permission.permission,1520			)1521		})1522		.map_err(<Error<T>>::from)?;15231524		Self::deposit_event(Event::PropertyPermissionSet(1525			collection.id,1526			property_permission.key,1527		));1528		<PalletEvm<T>>::deposit_log(1529			erc::CollectionHelpersEvents::CollectionChanged {1530				collection_id: eth::collection_id_to_address(collection.id),1531			}1532			.to_log(T::ContractAddress::get()),1533		);15341535		Ok(())1536	}15371538	/// Set token property permission.1539	///1540	/// * `collection` - Collection handler.1541	/// * `sender` - The owner or administrator of the collection.1542	/// * `property_permissions` - Property permissions.1543	#[transactional]1544	pub fn set_token_property_permissions(1545		collection: &CollectionHandle<T>,1546		sender: &T::CrossAccountId,1547		property_permissions: Vec<PropertyKeyPermission>,1548	) -> DispatchResult {1549		Self::set_scoped_token_property_permissions(1550			collection,1551			sender,1552			PropertyScope::None,1553			property_permissions,1554		)1555	}15561557	/// Set token property permission with scope.1558	///1559	/// * `collection` - Collection handler.1560	/// * `sender` - The owner or administrator of the collection.1561	/// * `scope` - Property scope.1562	/// * `property_permissions` - Property permissions.1563	#[transactional]1564	pub fn set_scoped_token_property_permissions(1565		collection: &CollectionHandle<T>,1566		sender: &T::CrossAccountId,1567		scope: PropertyScope,1568		property_permissions: Vec<PropertyKeyPermission>,1569	) -> DispatchResult {1570		for prop_pemission in property_permissions {1571			Self::set_scoped_property_permission(collection, sender, scope, prop_pemission)?;1572		}15731574		Ok(())1575	}15761577	/// Get collection property.1578	pub fn get_collection_property(1579		collection_id: CollectionId,1580		key: &PropertyKey,1581	) -> Option<PropertyValue> {1582		Self::collection_properties(collection_id).get(key).cloned()1583	}15841585	/// Convert byte vector to property key vector.1586	pub fn bytes_keys_to_property_keys(1587		keys: Vec<Vec<u8>>,1588	) -> Result<Vec<PropertyKey>, DispatchError> {1589		keys.into_iter()1590			.map(|key| -> Result<PropertyKey, DispatchError> {1591				key.try_into()1592					.map_err(|_| <Error<T>>::PropertyKeyIsTooLong.into())1593			})1594			.collect::<Result<Vec<PropertyKey>, DispatchError>>()1595	}15961597	/// Get properties according to given keys.1598	pub fn filter_collection_properties(1599		collection_id: CollectionId,1600		keys: Option<Vec<PropertyKey>>,1601	) -> Result<Vec<Property>, DispatchError> {1602		let properties = Self::collection_properties(collection_id);16031604		let properties = keys1605			.map(|keys| {1606				keys.into_iter()1607					.filter_map(|key| {1608						properties.get(&key).map(|value| Property {1609							key,1610							value: value.clone(),1611						})1612					})1613					.collect()1614			})1615			.unwrap_or_else(|| {1616				properties1617					.into_iter()1618					.map(|(key, value)| Property { key, value })1619					.collect()1620			});16211622		Ok(properties)1623	}16241625	/// Get property permissions according to given keys.1626	pub fn filter_property_permissions(1627		collection_id: CollectionId,1628		keys: Option<Vec<PropertyKey>>,1629	) -> Result<Vec<PropertyKeyPermission>, DispatchError> {1630		let permissions = Self::property_permissions(collection_id);16311632		let key_permissions = keys1633			.map(|keys| {1634				keys.into_iter()1635					.filter_map(|key| {1636						permissions1637							.get(&key)1638							.map(|permission| PropertyKeyPermission {1639								key,1640								permission: permission.clone(),1641							})1642					})1643					.collect()1644			})1645			.unwrap_or_else(|| {1646				permissions1647					.into_iter()1648					.map(|(key, permission)| PropertyKeyPermission { key, permission })1649					.collect()1650			});16511652		Ok(key_permissions)1653	}16541655	/// Toggle `user` participation in the `collection`'s allow list.1656	/// #### Store read/writes1657	/// 1 writes1658	pub fn toggle_allowlist(1659		collection: &CollectionHandle<T>,1660		sender: &T::CrossAccountId,1661		user: &T::CrossAccountId,1662		allowed: bool,1663	) -> DispatchResult {1664		collection.check_is_owner_or_admin(sender)?;16651666		// =========16671668		if allowed {1669			<Allowlist<T>>::insert((collection.id, user), true);1670			Self::deposit_event(Event::<T>::AllowListAddressAdded(1671				collection.id,1672				user.clone(),1673			));1674		} else {1675			<Allowlist<T>>::remove((collection.id, user));1676			Self::deposit_event(Event::<T>::AllowListAddressRemoved(1677				collection.id,1678				user.clone(),1679			));1680		}16811682		<PalletEvm<T>>::deposit_log(1683			erc::CollectionHelpersEvents::CollectionChanged {1684				collection_id: eth::collection_id_to_address(collection.id),1685			}1686			.to_log(T::ContractAddress::get()),1687		);16881689		Ok(())1690	}16911692	/// Toggle `user` participation in the `collection`'s admin list.1693	/// #### Store read/writes1694	/// 2 reads, 2 writes1695	pub fn toggle_admin(1696		collection: &CollectionHandle<T>,1697		sender: &T::CrossAccountId,1698		user: &T::CrossAccountId,1699		admin: bool,1700	) -> DispatchResult {1701		collection.check_is_internal()?;1702		collection.check_is_owner(sender)?;17031704		let is_admin = <IsAdmin<T>>::get((collection.id, user));1705		if is_admin == admin {1706			if admin {1707				return Ok(());1708			} else {1709				return Err(Error::<T>::UserIsNotCollectionAdmin.into());1710			}1711		}1712		let amount = <AdminAmount<T>>::get(collection.id);17131714		// =========17151716		if admin {1717			let amount = amount1718				.checked_add(1)1719				.ok_or(<Error<T>>::CollectionAdminCountExceeded)?;1720			ensure!(1721				amount <= Self::collection_admins_limit(),1722				<Error<T>>::CollectionAdminCountExceeded,1723			);17241725			<AdminAmount<T>>::insert(collection.id, amount);1726			<IsAdmin<T>>::insert((collection.id, user), true);17271728			Self::deposit_event(Event::<T>::CollectionAdminAdded(1729				collection.id,1730				user.clone(),1731			));1732		} else {1733			<AdminAmount<T>>::insert(collection.id, amount.saturating_sub(1));1734			<IsAdmin<T>>::remove((collection.id, user));17351736			Self::deposit_event(Event::<T>::CollectionAdminRemoved(1737				collection.id,1738				user.clone(),1739			));1740		}17411742		<PalletEvm<T>>::deposit_log(1743			erc::CollectionHelpersEvents::CollectionChanged {1744				collection_id: eth::collection_id_to_address(collection.id),1745			}1746			.to_log(T::ContractAddress::get()),1747		);17481749		Ok(())1750	}17511752	/// Update collection limits.1753	pub fn update_limits(1754		user: &T::CrossAccountId,1755		collection: &mut CollectionHandle<T>,1756		new_limit: CollectionLimits,1757	) -> DispatchResult {1758		collection.check_is_internal()?;1759		collection.check_is_owner_or_admin(user)?;17601761		collection.limits =1762			Self::clamp_limits(collection.mode.clone(), &collection.limits, new_limit)?;17631764		Self::deposit_event(Event::<T>::CollectionLimitSet(collection.id));1765		<PalletEvm<T>>::deposit_log(1766			erc::CollectionHelpersEvents::CollectionChanged {1767				collection_id: eth::collection_id_to_address(collection.id),1768			}1769			.to_log(T::ContractAddress::get()),1770		);17711772		collection.save()1773	}17741775	/// Merge set fields from `new_limit` to `old_limit`.1776	fn clamp_limits(1777		mode: CollectionMode,1778		old_limit: &CollectionLimits,1779		mut new_limit: CollectionLimits,1780	) -> Result<CollectionLimits, DispatchError> {1781		let limits = old_limit;1782		limit_default!(old_limit, new_limit,1783			account_token_ownership_limit => ensure!(1784				new_limit <= MAX_TOKEN_OWNERSHIP,1785				<Error<T>>::CollectionLimitBoundsExceeded,1786			),1787			sponsored_data_size => ensure!(1788				new_limit <= CUSTOM_DATA_LIMIT,1789				<Error<T>>::CollectionLimitBoundsExceeded,1790			),17911792			sponsored_data_rate_limit => {},1793			token_limit => ensure!(1794				old_limit >= new_limit && new_limit > 0,1795				<Error<T>>::CollectionTokenLimitExceeded1796			),17971798			sponsor_transfer_timeout(match mode {1799				CollectionMode::NFT => NFT_SPONSOR_TRANSFER_TIMEOUT,1800				CollectionMode::Fungible(_) => FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,1801				CollectionMode::ReFungible => REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,1802			}) => ensure!(1803				new_limit <= MAX_SPONSOR_TIMEOUT,1804				<Error<T>>::CollectionLimitBoundsExceeded,1805			),1806			sponsor_approve_timeout => {},1807			owner_can_transfer => ensure!(1808				!limits.owner_can_transfer_instaled() ||1809				old_limit || !new_limit,1810				<Error<T>>::OwnerPermissionsCantBeReverted,1811			),1812			owner_can_destroy => ensure!(1813				old_limit || !new_limit,1814				<Error<T>>::OwnerPermissionsCantBeReverted,1815			),1816			transfers_enabled => {},1817		);1818		Ok(new_limit)1819	}18201821	/// Update collection permissions.1822	pub fn update_permissions(1823		user: &T::CrossAccountId,1824		collection: &mut CollectionHandle<T>,1825		new_permission: CollectionPermissions,1826	) -> DispatchResult {1827		collection.check_is_internal()?;1828		collection.check_is_owner_or_admin(user)?;1829		collection.permissions = Self::clamp_permissions(1830			collection.mode.clone(),1831			&collection.permissions,1832			new_permission,1833		)?;18341835		Self::deposit_event(Event::<T>::CollectionPermissionSet(collection.id));1836		<PalletEvm<T>>::deposit_log(1837			erc::CollectionHelpersEvents::CollectionChanged {1838				collection_id: eth::collection_id_to_address(collection.id),1839			}1840			.to_log(T::ContractAddress::get()),1841		);18421843		collection.save()1844	}18451846	/// Merge set fields from `new_permission` to `old_permission`.1847	fn clamp_permissions(1848		_mode: CollectionMode,1849		old_permission: &CollectionPermissions,1850		mut new_permission: CollectionPermissions,1851	) -> Result<CollectionPermissions, DispatchError> {1852		limit_default_clone!(old_permission, new_permission,1853			access => {},1854			mint_mode => {},1855			nesting => { /* todo check for permissive, if only it gets out of benchmarks */ },1856		);1857		Ok(new_permission)1858	}18591860	/// Repair possibly broken properties of a collection.1861	pub fn repair_collection(collection_id: CollectionId) -> DispatchResult {1862		CollectionProperties::<T>::mutate(collection_id, |properties| {1863			properties.recompute_consumed_space();1864		});18651866		Ok(())1867	}1868}18691870/// Indicates unsupported methods by returning [Error::UnsupportedOperation].1871#[macro_export]1872macro_rules! unsupported {1873	($runtime:path) => {1874		Err($crate::Error::<$runtime>::UnsupportedOperation.into())1875	};1876}18771878/// Return weights for various worst-case operations.1879pub trait CommonWeightInfo<CrossAccountId> {1880	/// Weight of item creation.1881	fn create_item(data: &CreateItemData) -> Weight {1882		Self::create_multiple_items(from_ref(data))1883	}18841885	/// Weight of items creation.1886	fn create_multiple_items(amount: &[CreateItemData]) -> Weight;18871888	/// Weight of items creation.1889	fn create_multiple_items_ex(cost: &CreateItemExData<CrossAccountId>) -> Weight;18901891	/// The weight of the burning item.1892	fn burn_item() -> Weight;18931894	/// Property setting weight.1895	///1896	/// * `amount`- The number of properties to set.1897	fn set_collection_properties(amount: u32) -> Weight;18981899	/// Collection property deletion weight.1900	///1901	/// * `amount`- The number of properties to set.1902	fn delete_collection_properties(amount: u32) -> Weight;19031904	/// Token property setting weight.1905	///1906	/// * `amount`- The number of properties to set.1907	fn set_token_properties(amount: u32) -> Weight;19081909	/// Token property deletion weight.1910	///1911	/// * `amount`- The number of properties to delete.1912	fn delete_token_properties(amount: u32) -> Weight;19131914	/// Token property permissions set weight.1915	///1916	/// * `amount`- The number of property permissions to set.1917	fn set_token_property_permissions(amount: u32) -> Weight;19181919	/// Transfer price of the token or its parts.1920	fn transfer() -> Weight;19211922	/// The price of setting the permission of the operation from another user.1923	fn approve() -> Weight;19241925	/// The price of setting the permission of the operation from another user for eth mirror.1926	fn approve_from() -> Weight;19271928	/// Transfer price from another user.1929	fn transfer_from() -> Weight;19301931	/// The price of burning a token from another user.1932	fn burn_from() -> Weight;19331934	/// Differs from burn_item in case of Fungible and Refungible, as it should burn1935	/// whole users's balance.1936	///1937	/// This method shouldn't be used directly, as it doesn't count breadth price, use [burn_recursively](CommonWeightInfo::burn_recursively) instead1938	fn burn_recursively_self_raw() -> Weight;19391940	/// Cost of iterating over `amount` children while burning, without counting child burning itself.1941	///1942	/// This method shouldn't be used directly, as it doesn't count depth price, use [burn_recursively](CommonWeightInfo::burn_recursively) instead1943	fn burn_recursively_breadth_raw(amount: u32) -> Weight;19441945	/// The price of recursive burning a token.1946	///1947	/// `max_selfs` - The maximum burning weight of the token itself.1948	/// `max_breadth` - The maximum number of nested tokens to burn.1949	fn burn_recursively(max_selfs: u32, max_breadth: u32) -> Weight {1950		Self::burn_recursively_self_raw()1951			.saturating_mul(max_selfs.max(1) as u64)1952			.saturating_add(Self::burn_recursively_breadth_raw(max_breadth))1953	}19541955	/// The price of retrieving token owner1956	fn token_owner() -> Weight;19571958	/// The price of setting approval for all1959	fn set_allowance_for_all() -> Weight;19601961	/// The price of repairing an item.1962	fn force_repair_item() -> Weight;1963}19641965/// Weight info extension trait for refungible pallet.1966pub trait RefungibleExtensionsWeightInfo {1967	/// Weight of token repartition.1968	fn repartition() -> Weight;1969}19701971/// Common collection operations.1972///1973/// It wraps methods in Fungible, Nonfungible and Refungible pallets1974/// and adds weight info.1975pub trait CommonCollectionOperations<T: Config> {1976	/// Create token.1977	///1978	/// * `sender` - The user who mint the token and pays for the transaction.1979	/// * `to` - The user who will own the token.1980	/// * `data` - Token data.1981	/// * `nesting_budget` - A budget that can be spent on nesting tokens.1982	fn create_item(1983		&self,1984		sender: T::CrossAccountId,1985		to: T::CrossAccountId,1986		data: CreateItemData,1987		nesting_budget: &dyn Budget,1988	) -> DispatchResultWithPostInfo;19891990	/// Create multiple tokens.1991	///1992	/// * `sender` - The user who mint the token and pays for the transaction.1993	/// * `to` - The user who will own the token.1994	/// * `data` - Token data.1995	/// * `nesting_budget` - A budget that can be spent on nesting tokens.1996	fn create_multiple_items(1997		&self,1998		sender: T::CrossAccountId,1999		to: T::CrossAccountId,2000		data: Vec<CreateItemData>,2001		nesting_budget: &dyn Budget,2002	) -> DispatchResultWithPostInfo;20032004	/// Create multiple tokens.2005	///2006	/// * `sender` - The user who mint the token and pays for the transaction.2007	/// * `to` - The user who will own the token.2008	/// * `data` - Token data.2009	/// * `nesting_budget` - A budget that can be spent on nesting tokens.2010	fn create_multiple_items_ex(2011		&self,2012		sender: T::CrossAccountId,2013		data: CreateItemExData<T::CrossAccountId>,2014		nesting_budget: &dyn Budget,2015	) -> DispatchResultWithPostInfo;20162017	/// Burn token.2018	///2019	/// * `sender` - The user who owns the token.2020	/// * `token` - Token id that will burned.2021	/// * `amount` - The number of parts of the token that will be burned.2022	fn burn_item(2023		&self,2024		sender: T::CrossAccountId,2025		token: TokenId,2026		amount: u128,2027	) -> DispatchResultWithPostInfo;20282029	/// Burn token and all nested tokens recursievly.2030	///2031	/// * `sender` - The user who owns the token.2032	/// * `token` - Token id that will burned.2033	/// * `self_budget` - The budget that can be spent on burning tokens.2034	/// * `breadth_budget` - The budget that can be spent on burning nested tokens.2035	fn burn_item_recursively(2036		&self,2037		sender: T::CrossAccountId,2038		token: TokenId,2039		self_budget: &dyn Budget,2040		breadth_budget: &dyn Budget,2041	) -> DispatchResultWithPostInfo;20422043	/// Set collection properties.2044	///2045	/// * `sender` - Must be either the owner of the collection or its admin.2046	/// * `properties` - Properties to be set.2047	fn set_collection_properties(2048		&self,2049		sender: T::CrossAccountId,2050		properties: Vec<Property>,2051	) -> DispatchResultWithPostInfo;20522053	/// Delete collection properties.2054	///2055	/// * `sender` - Must be either the owner of the collection or its admin.2056	/// * `properties` - The properties to be removed.2057	fn delete_collection_properties(2058		&self,2059		sender: &T::CrossAccountId,2060		property_keys: Vec<PropertyKey>,2061	) -> DispatchResultWithPostInfo;20622063	/// Set token properties.2064	///2065	/// The appropriate [`PropertyPermission`] for the token property2066	/// must be set with [`Self::set_token_property_permissions`].2067	///2068	/// * `sender` - Must be either the owner of the token or its admin.2069	/// * `token_id` - The token for which the properties are being set.2070	/// * `properties` - Properties to be set.2071	/// * `budget` - Budget for setting properties.2072	fn set_token_properties(2073		&self,2074		sender: T::CrossAccountId,2075		token_id: TokenId,2076		properties: Vec<Property>,2077		budget: &dyn Budget,2078	) -> DispatchResultWithPostInfo;20792080	/// Remove token properties.2081	///2082	/// The appropriate [`PropertyPermission`] for the token property2083	/// must be set with [`Self::set_token_property_permissions`].2084	///2085	/// * `sender` - Must be either the owner of the token or its admin.2086	/// * `token_id` - The token for which the properties are being remove.2087	/// * `property_keys` - Keys to remove corresponding properties.2088	/// * `budget` - Budget for removing properties.2089	fn delete_token_properties(2090		&self,2091		sender: T::CrossAccountId,2092		token_id: TokenId,2093		property_keys: Vec<PropertyKey>,2094		budget: &dyn Budget,2095	) -> DispatchResultWithPostInfo;20962097	/// Set token property permissions.2098	///2099	/// * `sender` - Must be either the owner of the token or its admin.2100	/// * `token_id` - The token for which the properties are being set.2101	/// * `property_permissions` - Property permissions to be set.2102	/// * `budget` - Budget for setting properties.2103	fn set_token_property_permissions(2104		&self,2105		sender: &T::CrossAccountId,2106		property_permissions: Vec<PropertyKeyPermission>,2107	) -> DispatchResultWithPostInfo;21082109	/// Transfer amount of token pieces.2110	///2111	/// * `sender` - Donor user.2112	/// * `to` - Recepient user.2113	/// * `token` - The token of which parts are being sent.2114	/// * `amount` - The number of parts of the token that will be transferred.2115	/// * `budget` - The maximum budget that can be spent on the transfer.2116	fn transfer(2117		&self,2118		sender: T::CrossAccountId,2119		to: T::CrossAccountId,2120		token: TokenId,2121		amount: u128,2122		budget: &dyn Budget,2123	) -> DispatchResultWithPostInfo;21242125	/// Grant access to another account to transfer parts of the token owned by the calling user via [Self::transfer_from].2126	///2127	/// * `sender` - The user who grants access to the token.2128	/// * `spender` - The user to whom the rights are granted.2129	/// * `token` - The token to which access is granted.2130	/// * `amount` - The amount of pieces that another user can dispose of.2131	fn approve(2132		&self,2133		sender: T::CrossAccountId,2134		spender: T::CrossAccountId,2135		token: TokenId,2136		amount: u128,2137	) -> DispatchResultWithPostInfo;21382139	/// Grant access to another account to transfer parts of the token owned by the calling user's eth mirror via [Self::transfer_from].2140	///2141	/// * `sender` - The user who grants access to the token.2142	/// * `from` - Spender's eth mirror.2143	/// * `to` - The user to whom the rights are granted.2144	/// * `token` - The token to which access is granted.2145	/// * `amount` - The amount of pieces that another user can dispose of.2146	fn approve_from(2147		&self,2148		sender: T::CrossAccountId,2149		from: T::CrossAccountId,2150		to: T::CrossAccountId,2151		token: TokenId,2152		amount: u128,2153	) -> DispatchResultWithPostInfo;21542155	/// Send parts of a token owned by another user.2156	///2157	/// Before calling this method, you must grant rights to the calling user via [`Self::approve`].2158	///2159	/// * `sender` - The user who must have access to the token (see [`Self::approve`]).2160	/// * `from` - The user who owns the token.2161	/// * `to` - Recepient user.2162	/// * `token` - The token of which parts are being sent.2163	/// * `amount` - The number of parts of the token that will be transferred.2164	/// * `budget` - The maximum budget that can be spent on the transfer.2165	fn transfer_from(2166		&self,2167		sender: T::CrossAccountId,2168		from: T::CrossAccountId,2169		to: T::CrossAccountId,2170		token: TokenId,2171		amount: u128,2172		budget: &dyn Budget,2173	) -> DispatchResultWithPostInfo;21742175	/// Burn parts of a token owned by another user.2176	///2177	/// Before calling this method, you must grant rights to the calling user via [`Self::approve`].2178	///2179	/// * `sender` - The user who must have access to the token (see [`Self::approve`]).2180	/// * `from` - The user who owns the token.2181	/// * `token` - The token of which parts are being sent.2182	/// * `amount` - The number of parts of the token that will be transferred.2183	/// * `budget` - The maximum budget that can be spent on the burn.2184	fn burn_from(2185		&self,2186		sender: T::CrossAccountId,2187		from: T::CrossAccountId,2188		token: TokenId,2189		amount: u128,2190		budget: &dyn Budget,2191	) -> DispatchResultWithPostInfo;21922193	/// Check permission to nest token.2194	///2195	/// * `sender` - The user who initiated the check.2196	/// * `from` - The token that is checked for embedding.2197	/// * `under` - Token under which to check.2198	/// * `budget` - The maximum budget that can be spent on the check.2199	fn check_nesting(2200		&self,2201		sender: T::CrossAccountId,2202		from: (CollectionId, TokenId),2203		under: TokenId,2204		budget: &dyn Budget,2205	) -> DispatchResult;22062207	/// Nest one token into another.2208	///2209	/// * `under` - Token holder.2210	/// * `to_nest` - Nested token.2211	fn nest(&self, under: TokenId, to_nest: (CollectionId, TokenId));22122213	/// Unnest token.2214	///2215	/// * `under` - Token holder.2216	/// * `to_nest` - Token to unnest.2217	fn unnest(&self, under: TokenId, to_nest: (CollectionId, TokenId));22182219	/// Get all user tokens.2220	///2221	/// * `account` - Account for which you need to get tokens.2222	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId>;22232224	/// Get all the tokens in the collection.2225	fn collection_tokens(&self) -> Vec<TokenId>;22262227	/// Check if the token exists.2228	///2229	/// * `token` - Id token to check.2230	fn token_exists(&self, token: TokenId) -> bool;22312232	/// Get the id of the last minted token.2233	fn last_token_id(&self) -> TokenId;22342235	/// Get the owner of the token.2236	///2237	/// * `token` - The token for which you need to find out the owner.2238	fn token_owner(&self, token: TokenId) -> Result<T::CrossAccountId, TokenOwnerError>;22392240	/// Returns 10 tokens owners in no particular order.2241	///2242	/// * `token` - The token for which you need to find out the owners.2243	fn token_owners(&self, token: TokenId) -> Vec<T::CrossAccountId>;22442245	/// Get the value of the token property by key.2246	///2247	/// * `token` - Token with the property to get.2248	/// * `key` - Property name.2249	fn token_property(&self, token_id: TokenId, key: &PropertyKey) -> Option<PropertyValue>;22502251	/// Get a set of token properties by key vector.2252	///2253	/// * `token` - Token with the property to get.2254	/// * `keys` - Vector of property keys. If this parameter is [None](sp_std::result::Result),2255	/// then all properties are returned.2256	fn token_properties(&self, token: TokenId, keys: Option<Vec<PropertyKey>>) -> Vec<Property>;22572258	/// Amount of unique collection tokens2259	fn total_supply(&self) -> u32;22602261	/// Amount of different tokens account has.2262	///2263	/// * `account` - The account for which need to get the balance.2264	fn account_balance(&self, account: T::CrossAccountId) -> u32;22652266	/// Amount of specific token account have.2267	fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128;22682269	/// Amount of token pieces2270	fn total_pieces(&self, token: TokenId) -> Option<u128>;22712272	/// Get the number of parts of the token that a trusted user can manage.2273	///2274	/// * `sender` - Trusted user.2275	/// * `spender` - Owner of the token.2276	/// * `token` - The token for which to get the value.2277	fn allowance(2278		&self,2279		sender: T::CrossAccountId,2280		spender: T::CrossAccountId,2281		token: TokenId,2282	) -> u128;22832284	/// Get extension for RFT collection.2285	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>>;22862287	/// The `operator` is allowed to transfer all tokens of the `owner` on their behalf.2288	/// * `owner` - Token owner2289	/// * `operator` - Operator2290	/// * `approve` - Should operator status be granted or revoked?2291	fn set_allowance_for_all(2292		&self,2293		owner: T::CrossAccountId,2294		operator: T::CrossAccountId,2295		approve: bool,2296	) -> DispatchResultWithPostInfo;22972298	/// Tells whether the given `owner` approves the `operator`.2299	fn allowance_for_all(&self, owner: T::CrossAccountId, operator: T::CrossAccountId) -> bool;23002301	/// Repairs a possibly broken item.2302	fn repair_item(&self, token: TokenId) -> DispatchResultWithPostInfo;2303}23042305/// Extension for RFT collection.2306pub trait RefungibleExtensions<T>2307where2308	T: Config,2309{2310	/// Change the number of parts of the token.2311	///2312	/// When the value changes down, this function is equivalent to burning parts of the token.2313	///2314	/// * `sender` - The user calling the repartition operation. Must be the owner of the token.2315	/// * `token` - The token for which you want to change the number of parts.2316	/// * `amount` - The new value of the parts of the token.2317	fn repartition(2318		&self,2319		sender: &T::CrossAccountId,2320		token: TokenId,2321		amount: u128,2322	) -> DispatchResultWithPostInfo;2323}23242325/// Merge [`DispatchResult`] with [`Weight`] into [`DispatchResultWithPostInfo`].2326///2327/// Used for [`CommonCollectionOperations`] implementations and flexible enough to do so.2328pub fn with_weight(res: DispatchResult, weight: Weight) -> DispatchResultWithPostInfo {2329	let post_info = PostDispatchInfo {2330		actual_weight: Some(weight),2331		pays_fee: Pays::Yes,2332	};2333	match res {2334		Ok(()) => Ok(post_info),2335		Err(error) => Err(DispatchErrorWithPostInfo { post_info, error }),2336	}2337}23382339impl<T: Config> From<PropertiesError> for Error<T> {2340	fn from(error: PropertiesError) -> Self {2341		match error {2342			PropertiesError::NoSpaceForProperty => Self::NoSpaceForProperty,2343			PropertiesError::PropertyLimitReached => Self::PropertyLimitReached,2344			PropertiesError::InvalidCharacterInPropertyKey => Self::InvalidCharacterInPropertyKey,2345			PropertiesError::PropertyKeyIsTooLong => Self::PropertyKeyIsTooLong,2346			PropertiesError::EmptyPropertyKey => Self::EmptyPropertyKey,2347		}2348	}2349}