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

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	dispatch::Pays,66	transactional,67};68use pallet_evm::GasWeightMapping;69use up_data_structs::{70	COLLECTION_NUMBER_LIMIT,71	Collection,72	RpcCollection,73	CollectionFlags,74	RpcCollectionFlags,75	CollectionId,76	CreateItemData,77	MAX_TOKEN_PREFIX_LENGTH,78	COLLECTION_ADMINS_LIMIT,79	TokenId,80	TokenChild,81	CollectionStats,82	MAX_TOKEN_OWNERSHIP,83	CollectionMode,84	NFT_SPONSOR_TRANSFER_TIMEOUT,85	FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,86	REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,87	MAX_SPONSOR_TIMEOUT,88	CUSTOM_DATA_LIMIT,89	CollectionLimits,90	CreateCollectionData,91	SponsorshipState,92	CreateItemExData,93	SponsoringRateLimit,94	budget::Budget,95	PhantomType,96	Property,97	Properties,98	PropertiesPermissionMap,99	PropertyKey,100	PropertyValue,101	PropertyPermission,102	PropertiesError,103	PropertyKeyPermission,104	TokenData,105	TrySetProperty,106	PropertyScope,107	// RMRK108	RmrkCollectionInfo,109	RmrkInstanceInfo,110	RmrkResourceInfo,111	RmrkPropertyInfo,112	RmrkBaseInfo,113	RmrkPartType,114	RmrkBoundedTheme,115	RmrkNftChild,116	CollectionPermissions,117};118119pub use pallet::*;120use sp_core::H160;121use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};122#[cfg(feature = "runtime-benchmarks")]123pub mod benchmarking;124pub mod dispatch;125pub mod erc;126pub mod eth;127pub mod weights;128129/// Weight info.130pub type SelfWeightOf<T> = <T as Config>::WeightInfo;131132/// Collection handle contains information about collection data and id.133/// Also provides functionality to count consumed gas.134///135/// CollectionHandle is used as a generic wrapper for collections of all types.136/// It allows to perform common operations and queries on any collection type,137/// both completely general for all, as well as their respective implementations of [`CommonCollectionOperations`].138#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]139pub struct CollectionHandle<T: Config> {140	/// Collection id141	pub id: CollectionId,142	collection: Collection<T::AccountId>,143	/// Substrate recorder for counting consumed gas144	pub recorder: SubstrateRecorder<T>,145}146147impl<T: Config> WithRecorder<T> for CollectionHandle<T> {148	fn recorder(&self) -> &SubstrateRecorder<T> {149		&self.recorder150	}151	fn into_recorder(self) -> SubstrateRecorder<T> {152		self.recorder153	}154}155156impl<T: Config> CollectionHandle<T> {157	/// Same as [CollectionHandle::new] but with an explicit gas limit.158	pub fn new_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {159		<CollectionById<T>>::get(id).map(|collection| Self {160			id,161			collection,162			recorder: SubstrateRecorder::new(gas_limit),163		})164	}165166	/// Same as [CollectionHandle::new] but with an existed [`SubstrateRecorder`].167	pub fn new_with_recorder(id: CollectionId, recorder: SubstrateRecorder<T>) -> Option<Self> {168		<CollectionById<T>>::get(id).map(|collection| Self {169			id,170			collection,171			recorder,172		})173	}174175	/// Retrives collection data from storage and creates collection handle with default parameters.176	/// If collection not found return `None`177	pub fn new(id: CollectionId) -> Option<Self> {178		Self::new_with_gas_limit(id, u64::MAX)179	}180181	/// Same as [`CollectionHandle::new`] but if collection not found [CollectionNotFound](Error::CollectionNotFound) returned.182	pub fn try_get(id: CollectionId) -> Result<Self, DispatchError> {183		Ok(Self::new(id).ok_or(<Error<T>>::CollectionNotFound)?)184	}185186	/// Consume gas for reading.187	pub fn consume_store_reads(&self, reads: u64) -> evm_coder::execution::Result<()> {188		self.recorder189			.consume_gas(T::GasWeightMapping::weight_to_gas(Weight::from_ref_time(190				<T as frame_system::Config>::DbWeight::get()191					.read192					.saturating_mul(reads),193			)))194	}195196	/// Consume gas for writing.197	pub fn consume_store_writes(&self, writes: u64) -> evm_coder::execution::Result<()> {198		self.recorder199			.consume_gas(T::GasWeightMapping::weight_to_gas(Weight::from_ref_time(200				<T as frame_system::Config>::DbWeight::get()201					.write202					.saturating_mul(writes),203			)))204	}205206	/// Consume gas for reading and writing.207	pub fn consume_store_reads_and_writes(208		&self,209		reads: u64,210		writes: u64,211	) -> evm_coder::execution::Result<()> {212		let weight = <T as frame_system::Config>::DbWeight::get();213		let reads = weight.read.saturating_mul(reads);214		let writes = weight.read.saturating_mul(writes);215		self.recorder216			.consume_gas(T::GasWeightMapping::weight_to_gas(Weight::from_ref_time(217				reads.saturating_add(writes),218			)))219	}220221	/// Save collection to storage.222	pub fn save(&self) -> DispatchResult {223		<CollectionById<T>>::insert(self.id, &self.collection);224		Ok(())225	}226227	/// Set collection sponsor.228	///229	/// Unique collections allows sponsoring for certain actions.230	/// This method allows you to set the sponsor of the collection.231	/// In order for sponsorship to become active, it must be confirmed through [`Self::confirm_sponsorship`].232	pub fn set_sponsor(233		&mut self,234		sender: &T::CrossAccountId,235		sponsor: T::AccountId,236	) -> DispatchResult {237		self.check_is_internal()?;238		self.check_is_owner_or_admin(sender)?;239240		self.collection.sponsorship = SponsorshipState::Unconfirmed(sponsor.clone());241242		<Pallet<T>>::deposit_event(Event::<T>::CollectionSponsorSet(self.id, sponsor));243		<PalletEvm<T>>::deposit_log(244			erc::CollectionHelpersEvents::CollectionChanged {245				collection_id: eth::collection_id_to_address(self.id),246			}247			.to_log(T::ContractAddress::get()),248		);249250		self.save()251	}252253	/// Force set `sponsor`.254	///255	/// Differs from [`set_sponsor`][`Self::set_sponsor`] in that confirmation256	/// from the `sponsor` is not required.257	///258	/// # Arguments259	///260	/// * `sender`: Caller's account.261	/// * `sponsor`: ID of the account of the sponsor-to-be.262	pub fn force_set_sponsor(&mut self, sponsor: T::AccountId) -> DispatchResult {263		self.check_is_internal()?;264265		self.collection.sponsorship = SponsorshipState::Confirmed(sponsor.clone());266267		<Pallet<T>>::deposit_event(Event::<T>::CollectionSponsorSet(self.id, sponsor.clone()));268		<Pallet<T>>::deposit_event(Event::<T>::SponsorshipConfirmed(self.id, sponsor));269		<PalletEvm<T>>::deposit_log(270			erc::CollectionHelpersEvents::CollectionChanged {271				collection_id: eth::collection_id_to_address(self.id),272			}273			.to_log(T::ContractAddress::get()),274		);275276		self.save()277	}278279	/// Confirm sponsorship280	///281	/// In order for the sponsorship to become active, the user set as the sponsor must confirm their participation.282	/// Before confirming sponsorship, the user must be specified as the sponsor of the collection via [`Self::set_sponsor`].283	pub fn confirm_sponsorship(&mut self, sender: &T::AccountId) -> DispatchResult {284		self.check_is_internal()?;285		ensure!(286			self.collection.sponsorship.pending_sponsor() == Some(sender),287			Error::<T>::ConfirmSponsorshipFail288		);289290		self.collection.sponsorship = SponsorshipState::Confirmed(sender.clone());291292		<Pallet<T>>::deposit_event(Event::<T>::SponsorshipConfirmed(self.id, sender.clone()));293		<PalletEvm<T>>::deposit_log(294			erc::CollectionHelpersEvents::CollectionChanged {295				collection_id: eth::collection_id_to_address(self.id),296			}297			.to_log(T::ContractAddress::get()),298		);299300		self.save()301	}302303	/// Remove collection sponsor.304	pub fn remove_sponsor(&mut self, sender: &T::CrossAccountId) -> DispatchResult {305		self.check_is_internal()?;306		self.check_is_owner_or_admin(sender)?;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	/// Force remove `sponsor`.321	///322	/// Differs from `remove_sponsor` in that323	/// it doesn't require consent from the `owner` of the collection.324	pub fn force_remove_sponsor(&mut self) -> DispatchResult {325		self.check_is_internal()?;326327		self.collection.sponsorship = SponsorshipState::Disabled;328329		<Pallet<T>>::deposit_event(Event::<T>::CollectionSponsorRemoved(self.id));330		<PalletEvm<T>>::deposit_log(331			erc::CollectionHelpersEvents::CollectionChanged {332				collection_id: eth::collection_id_to_address(self.id),333			}334			.to_log(T::ContractAddress::get()),335		);336		self.save()337	}338339	/// Checks that the collection was created with, and must be operated upon through **Unique API**.340	/// Now check only the `external` flag and if it's **true**, then return [`Error::CollectionIsExternal`] error.341	pub fn check_is_internal(&self) -> DispatchResult {342		if self.flags.external {343			return Err(<Error<T>>::CollectionIsExternal)?;344		}345346		Ok(())347	}348349	/// Checks that the collection was created with, and must be operated upon through an **assimilated API**.350	/// Now check only the `external` flag and if it's **false**, then return [`Error::CollectionIsInternal`] error.351	pub fn check_is_external(&self) -> DispatchResult {352		if !self.flags.external {353			return Err(<Error<T>>::CollectionIsInternal)?;354		}355356		Ok(())357	}358}359360impl<T: Config> Deref for CollectionHandle<T> {361	type Target = Collection<T::AccountId>;362363	fn deref(&self) -> &Self::Target {364		&self.collection365	}366}367368impl<T: Config> DerefMut for CollectionHandle<T> {369	fn deref_mut(&mut self) -> &mut Self::Target {370		&mut self.collection371	}372}373374impl<T: Config> CollectionHandle<T> {375	/// Checks if the `user` is the owner of the collection.376	pub fn check_is_owner(&self, user: &T::CrossAccountId) -> DispatchResult {377		ensure!(*user.as_sub() == self.owner, <Error<T>>::NoPermission);378		Ok(())379	}380381	/// Returns **true** if the `user` is the owner or administrator of the collection.382	pub fn is_owner_or_admin(&self, user: &T::CrossAccountId) -> bool {383		*user.as_sub() == self.owner || <IsAdmin<T>>::get((self.id, user))384	}385386	/// Checks if the `user` is the owner or administrator of the collection.387	pub fn check_is_owner_or_admin(&self, user: &T::CrossAccountId) -> DispatchResult {388		ensure!(self.is_owner_or_admin(user), <Error<T>>::NoPermission);389		Ok(())390	}391392	/// Return **true** if `user` was not allowed to have tokens, and he can ignore such restrictions.393	pub fn ignores_allowance(&self, user: &T::CrossAccountId) -> bool {394		self.limits.owner_can_transfer() && self.is_owner_or_admin(user)395	}396397	/// Return **true** if `user` does not have enough token parts, and he can ignore such restrictions.398	pub fn ignores_owned_amount(&self, user: &T::CrossAccountId) -> bool {399		self.limits.owner_can_transfer() && self.is_owner_or_admin(user)400	}401402	/// Checks if the user is in the allow list. If not [Error::AddressNotInAllowlist] returns.403	pub fn check_allowlist(&self, user: &T::CrossAccountId) -> DispatchResult {404		ensure!(405			<Allowlist<T>>::get((self.id, user)),406			<Error<T>>::AddressNotInAllowlist407		);408		Ok(())409	}410411	/// Changes collection owner to another account412	/// #### Store read/writes413	/// 1 writes414	pub fn change_owner(415		&mut self,416		caller: T::CrossAccountId,417		new_owner: T::CrossAccountId,418	) -> DispatchResult {419		self.check_is_internal()?;420		self.check_is_owner(&caller)?;421		self.collection.owner = new_owner.as_sub().clone();422423		<Pallet<T>>::deposit_event(Event::<T>::CollectionOwnerChanged(424			self.id,425			new_owner.as_sub().clone(),426		));427		<PalletEvm<T>>::deposit_log(428			erc::CollectionHelpersEvents::CollectionChanged {429				collection_id: eth::collection_id_to_address(self.id),430			}431			.to_log(T::ContractAddress::get()),432		);433434		self.save()435	}436}437438#[frame_support::pallet]439pub mod pallet {440	use super::*;441	use dispatch::CollectionDispatch;442	use frame_support::{Blake2_128Concat, pallet_prelude::*, storage::Key, traits::StorageVersion};443	use frame_system::pallet_prelude::*;444	use frame_support::traits::Currency;445	use up_data_structs::{TokenId, mapping::TokenAddressMapping};446	use scale_info::TypeInfo;447	use weights::WeightInfo;448449	#[pallet::config]450	pub trait Config:451		frame_system::Config + pallet_evm_coder_substrate::Config + pallet_evm::Config + TypeInfo452	{453		/// Weight information for functions of this pallet.454		type WeightInfo: WeightInfo;455456		/// Events compatible with [`frame_system::Config::Event`].457		type RuntimeEvent: IsType<<Self as frame_system::Config>::RuntimeEvent> + From<Event<Self>>;458459		/// Handler of accounts and payment.460		type Currency: Currency<Self::AccountId>;461462		/// Set price to create a collection.463		#[pallet::constant]464		type CollectionCreationPrice: Get<465			<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,466		>;467468		/// Dispatcher of operations on collections.469		type CollectionDispatch: CollectionDispatch<Self>;470471		/// Account which holds the chain's treasury.472		type TreasuryAccountId: Get<Self::AccountId>;473474		/// Address under which the CollectionHelper contract would be available.475		#[pallet::constant]476		type ContractAddress: Get<H160>;477478		/// Mapper for token addresses to Ethereum addresses.479		type EvmTokenAddressMapping: TokenAddressMapping<H160>;480481		/// Mapper for token addresses to [`CrossAccountId`].482		type CrossTokenAddressMapping: TokenAddressMapping<Self::CrossAccountId>;483	}484485	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);486487	#[pallet::pallet]488	#[pallet::storage_version(STORAGE_VERSION)]489	#[pallet::generate_store(pub(super) trait Store)]490	pub struct Pallet<T>(_);491492	#[pallet::extra_constants]493	impl<T: Config> Pallet<T> {494		/// Maximum admins per collection.495		pub fn collection_admins_limit() -> u32 {496			COLLECTION_ADMINS_LIMIT497		}498	}499500	#[pallet::event]501	#[pallet::generate_deposit(pub fn deposit_event)]502	pub enum Event<T: Config> {503		/// New collection was created504		CollectionCreated(505			/// Globally unique identifier of newly created collection.506			CollectionId,507			/// [`CollectionMode`] converted into _u8_.508			u8,509			/// Collection owner.510			T::AccountId,511		),512513		/// New collection was destroyed514		CollectionDestroyed(515			/// Globally unique identifier of collection.516			CollectionId,517		),518519		/// New item was created.520		ItemCreated(521			/// Id of the collection where item was created.522			CollectionId,523			/// Id of an item. Unique within the collection.524			TokenId,525			/// Owner of newly created item526			T::CrossAccountId,527			/// Always 1 for NFT528			u128,529		),530531		/// Collection item was burned.532		ItemDestroyed(533			/// Id of the collection where item was destroyed.534			CollectionId,535			/// Identifier of burned NFT.536			TokenId,537			/// Which user has destroyed its tokens.538			T::CrossAccountId,539			/// Amount of token pieces destroed. Always 1 for NFT.540			u128,541		),542543		/// Item was transferred544		Transfer(545			/// Id of collection to which item is belong.546			CollectionId,547			/// Id of an item.548			TokenId,549			/// Original owner of item.550			T::CrossAccountId,551			/// New owner of item.552			T::CrossAccountId,553			/// Amount of token pieces transfered. Always 1 for NFT.554			u128,555		),556557		/// Amount pieces of token owned by `sender` was approved for `spender`.558		Approved(559			/// Id of collection to which item is belong.560			CollectionId,561			/// Id of an item.562			TokenId,563			/// Original owner of item.564			T::CrossAccountId,565			/// Id for which the approval was granted.566			T::CrossAccountId,567			/// Amount of token pieces transfered. Always 1 for NFT.568			u128,569		),570571		/// A `sender` approves operations on all owned tokens for `spender`.572		ApprovedForAll(573			/// Id of collection to which item is belong.574			CollectionId,575			/// Owner of a wallet.576			T::CrossAccountId,577			/// Id for which operator status was granted or rewoked.578			T::CrossAccountId,579			/// Is operator status granted or revoked?580			bool,581		),582583		/// The colletion property has been added or edited.584		CollectionPropertySet(585			/// Id of collection to which property has been set.586			CollectionId,587			/// The property that was set.588			PropertyKey,589		),590591		/// The property has been deleted.592		CollectionPropertyDeleted(593			/// Id of collection to which property has been deleted.594			CollectionId,595			/// The property that was deleted.596			PropertyKey,597		),598599		/// The token property has been added or edited.600		TokenPropertySet(601			/// Identifier of the collection whose token has the property set.602			CollectionId,603			/// The token for which the property was set.604			TokenId,605			/// The property that was set.606			PropertyKey,607		),608609		/// The token property has been deleted.610		TokenPropertyDeleted(611			/// Identifier of the collection whose token has the property deleted.612			CollectionId,613			/// The token for which the property was deleted.614			TokenId,615			/// The property that was deleted.616			PropertyKey,617		),618619		/// The token property permission of a collection has been set.620		PropertyPermissionSet(621			/// ID of collection to which property permission has been set.622			CollectionId,623			/// The property permission that was set.624			PropertyKey,625		),626627		/// Address was added to the allow list.628		AllowListAddressAdded(629			/// ID of the affected collection.630			CollectionId,631			/// Address of the added account.632			T::CrossAccountId,633		),634635		/// Address was removed from the allow list.636		AllowListAddressRemoved(637			/// ID of the affected collection.638			CollectionId,639			/// Address of the removed account.640			T::CrossAccountId,641		),642643		/// Collection admin was added.644		CollectionAdminAdded(645			/// ID of the affected collection.646			CollectionId,647			/// Admin address.648			T::CrossAccountId,649		),650651		/// Collection admin was removed.652		CollectionAdminRemoved(653			/// ID of the affected collection.654			CollectionId,655			/// Removed admin address.656			T::CrossAccountId,657		),658659		/// Collection limits were set.660		CollectionLimitSet(661			/// ID of the affected collection.662			CollectionId,663		),664665		/// Collection owned was changed.666		CollectionOwnerChanged(667			/// ID of the affected collection.668			CollectionId,669			/// New owner address.670			T::AccountId,671		),672673		/// Collection permissions were set.674		CollectionPermissionSet(675			/// ID of the affected collection.676			CollectionId,677		),678679		/// Collection sponsor was set.680		CollectionSponsorSet(681			/// ID of the affected collection.682			CollectionId,683			/// New sponsor address.684			T::AccountId,685		),686687		/// New sponsor was confirm.688		SponsorshipConfirmed(689			/// ID of the affected collection.690			CollectionId,691			/// New sponsor address.692			T::AccountId,693		),694695		/// Collection sponsor was removed.696		CollectionSponsorRemoved(697			/// ID of the affected collection.698			CollectionId,699		),700	}701702	#[pallet::error]703	pub enum Error<T> {704		/// This collection does not exist.705		CollectionNotFound,706		/// Sender parameter and item owner must be equal.707		MustBeTokenOwner,708		/// No permission to perform action709		NoPermission,710		/// Destroying only empty collections is allowed711		CantDestroyNotEmptyCollection,712		/// Collection is not in mint mode.713		PublicMintingNotAllowed,714		/// Address is not in allow list.715		AddressNotInAllowlist,716717		/// Collection name can not be longer than 63 char.718		CollectionNameLimitExceeded,719		/// Collection description can not be longer than 255 char.720		CollectionDescriptionLimitExceeded,721		/// Token prefix can not be longer than 15 char.722		CollectionTokenPrefixLimitExceeded,723		/// Total collections bound exceeded.724		TotalCollectionsLimitExceeded,725		/// Exceeded max admin count726		CollectionAdminCountExceeded,727		/// Collection limit bounds per collection exceeded728		CollectionLimitBoundsExceeded,729		/// Tried to enable permissions which are only permitted to be disabled730		OwnerPermissionsCantBeReverted,731		/// Collection settings not allowing items transferring732		TransferNotAllowed,733		/// Account token limit exceeded per collection734		AccountTokenLimitExceeded,735		/// Collection token limit exceeded736		CollectionTokenLimitExceeded,737		/// Metadata flag frozen738		MetadataFlagFrozen,739740		/// Item does not exist741		TokenNotFound,742		/// Item is balance not enough743		TokenValueTooLow,744		/// Requested value is more than the approved745		ApprovedValueTooLow,746		/// Tried to approve more than owned747		CantApproveMoreThanOwned,748749		/// Can't transfer tokens to ethereum zero address750		AddressIsZero,751752		/// The operation is not supported753		UnsupportedOperation,754755		/// Insufficient funds to perform an action756		NotSufficientFounds,757758		/// User does not satisfy the nesting rule759		UserIsNotAllowedToNest,760		/// Only tokens from specific collections may nest tokens under this one761		SourceCollectionIsNotAllowedToNest,762763		/// Tried to store more data than allowed in collection field764		CollectionFieldSizeExceeded,765766		/// Tried to store more property data than allowed767		NoSpaceForProperty,768769		/// Tried to store more property keys than allowed770		PropertyLimitReached,771772		/// Property key is too long773		PropertyKeyIsTooLong,774775		/// Only ASCII letters, digits, and symbols `_`, `-`, and `.` are allowed776		InvalidCharacterInPropertyKey,777778		/// Empty property keys are forbidden779		EmptyPropertyKey,780781		/// Tried to access an external collection with an internal API782		CollectionIsExternal,783784		/// Tried to access an internal collection with an external API785		CollectionIsInternal,786787		/// This address is not set as sponsor, use setCollectionSponsor first.788		ConfirmSponsorshipFail,789790		/// The user is not an administrator.791		UserIsNotCollectionAdmin,792	}793794	/// Storage of the count of created collections. Essentially contains the last collection ID.795	#[pallet::storage]796	pub type CreatedCollectionCount<T> = StorageValue<Value = CollectionId, QueryKind = ValueQuery>;797798	/// Storage of the count of deleted collections.799	#[pallet::storage]800	pub type DestroyedCollectionCount<T> =801		StorageValue<Value = CollectionId, QueryKind = ValueQuery>;802803	/// Storage of collection info.804	#[pallet::storage]805	pub type CollectionById<T> = StorageMap<806		Hasher = Blake2_128Concat,807		Key = CollectionId,808		Value = Collection<<T as frame_system::Config>::AccountId>,809		QueryKind = OptionQuery,810	>;811812	/// Storage of collection properties.813	#[pallet::storage]814	#[pallet::getter(fn collection_properties)]815	pub type CollectionProperties<T> = StorageMap<816		Hasher = Blake2_128Concat,817		Key = CollectionId,818		Value = Properties,819		QueryKind = ValueQuery,820		OnEmpty = up_data_structs::CollectionProperties,821	>;822823	/// Storage of token property permissions of a collection.824	#[pallet::storage]825	#[pallet::getter(fn property_permissions)]826	pub type CollectionPropertyPermissions<T> = StorageMap<827		Hasher = Blake2_128Concat,828		Key = CollectionId,829		Value = PropertiesPermissionMap,830		QueryKind = ValueQuery,831	>;832833	/// Storage of the amount of collection admins.834	#[pallet::storage]835	pub type AdminAmount<T> = StorageMap<836		Hasher = Blake2_128Concat,837		Key = CollectionId,838		Value = u32,839		QueryKind = ValueQuery,840	>;841842	/// List of collection admins.843	#[pallet::storage]844	pub type IsAdmin<T: Config> = StorageNMap<845		Key = (846			Key<Blake2_128Concat, CollectionId>,847			Key<Blake2_128Concat, T::CrossAccountId>,848		),849		Value = bool,850		QueryKind = ValueQuery,851	>;852853	/// Allowlisted collection users.854	#[pallet::storage]855	pub type Allowlist<T: Config> = StorageNMap<856		Key = (857			Key<Blake2_128Concat, CollectionId>,858			Key<Blake2_128Concat, T::CrossAccountId>,859		),860		Value = bool,861		QueryKind = ValueQuery,862	>;863864	/// Not used by code, exists only to provide some types to metadata.865	#[pallet::storage]866	pub type DummyStorageValue<T: Config> = StorageValue<867		Value = (868			CollectionStats,869			CollectionId,870			TokenId,871			TokenChild,872			PhantomType<(873				TokenData<T::CrossAccountId>,874				RpcCollection<T::AccountId>,875				// RMRK876				RmrkCollectionInfo<T::AccountId>,877				RmrkInstanceInfo<T::AccountId>,878				RmrkResourceInfo,879				RmrkPropertyInfo,880				RmrkBaseInfo<T::AccountId>,881				RmrkPartType,882				RmrkBoundedTheme,883				RmrkNftChild,884			)>,885		),886		QueryKind = OptionQuery,887	>;888889	#[pallet::hooks]890	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {891		fn on_runtime_upgrade() -> Weight {892			StorageVersion::new(1).put::<Pallet<T>>();893894			Weight::zero()895		}896	}897}898899impl<T: Config> Pallet<T> {900	/// Enshure that receiver address is correct.901	///902	/// Ethereum receiver 0x0000000000000000000000000000000000000000 is reserved, and shouldn't own tokens.903	pub fn ensure_correct_receiver(receiver: &T::CrossAccountId) -> DispatchResult {904		ensure!(905			&T::CrossAccountId::from_eth(H160([0; 20])) != receiver,906			<Error<T>>::AddressIsZero907		);908		Ok(())909	}910911	/// Get a vector of collection admins.912	pub fn adminlist(collection: CollectionId) -> Vec<T::CrossAccountId> {913		<IsAdmin<T>>::iter_prefix((collection,))914			.map(|(a, _)| a)915			.collect()916	}917918	/// Get a vector of users allowed to mint tokens.919	pub fn allowlist(collection: CollectionId) -> Vec<T::CrossAccountId> {920		<Allowlist<T>>::iter_prefix((collection,))921			.map(|(a, _)| a)922			.collect()923	}924925	/// Is `user` allowed to mint token in `collection`.926	pub fn allowed(collection: CollectionId, user: T::CrossAccountId) -> bool {927		<Allowlist<T>>::get((collection, user))928	}929930	/// Get statistics of collections.931	pub fn collection_stats() -> CollectionStats {932		let created = <CreatedCollectionCount<T>>::get();933		let destroyed = <DestroyedCollectionCount<T>>::get();934		CollectionStats {935			created: created.0,936			destroyed: destroyed.0,937			alive: created.0 - destroyed.0,938		}939	}940941	/// Get the effective limits for the collection.942	pub fn effective_collection_limits(collection: CollectionId) -> Option<CollectionLimits> {943		let collection = <CollectionById<T>>::get(collection)?;944		let limits = collection.limits;945		let effective_limits = CollectionLimits {946			account_token_ownership_limit: Some(limits.account_token_ownership_limit()),947			sponsored_data_size: Some(limits.sponsored_data_size()),948			sponsored_data_rate_limit: Some(949				limits950					.sponsored_data_rate_limit951					.unwrap_or(SponsoringRateLimit::SponsoringDisabled),952			),953			token_limit: Some(limits.token_limit()),954			sponsor_transfer_timeout: Some(limits.sponsor_transfer_timeout(955				match collection.mode {956					CollectionMode::NFT => NFT_SPONSOR_TRANSFER_TIMEOUT,957					CollectionMode::Fungible(_) => FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,958					CollectionMode::ReFungible => REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,959				},960			)),961			sponsor_approve_timeout: Some(limits.sponsor_approve_timeout()),962			owner_can_transfer: Some(limits.owner_can_transfer()),963			owner_can_destroy: Some(limits.owner_can_destroy()),964			transfers_enabled: Some(limits.transfers_enabled()),965		};966967		Some(effective_limits)968	}969970	/// Returns information about the `collection` adapted for rpc.971	pub fn rpc_collection(collection: CollectionId) -> Option<RpcCollection<T::AccountId>> {972		let Collection {973			name,974			description,975			owner,976			mode,977			token_prefix,978			sponsorship,979			limits,980			permissions,981			flags,982		} = <CollectionById<T>>::get(collection)?;983984		let token_property_permissions = <CollectionPropertyPermissions<T>>::get(collection)985			.into_iter()986			.map(|(key, permission)| PropertyKeyPermission { key, permission })987			.collect();988989		let properties = <CollectionProperties<T>>::get(collection)990			.into_iter()991			.map(|(key, value)| Property { key, value })992			.collect();993994		let permissions = CollectionPermissions {995			access: Some(permissions.access()),996			mint_mode: Some(permissions.mint_mode()),997			nesting: Some(permissions.nesting().clone()),998		};9991000		Some(RpcCollection {1001			name: name.into_inner(),1002			description: description.into_inner(),1003			owner,1004			mode,1005			token_prefix: token_prefix.into_inner(),1006			sponsorship,1007			limits,1008			permissions,1009			token_property_permissions,1010			properties,1011			read_only: flags.external,10121013			flags: RpcCollectionFlags {1014				foreign: flags.foreign,1015				erc721metadata: flags.erc721metadata,1016			},1017		})1018	}1019}10201021macro_rules! limit_default {1022	($old:ident, $new:ident, $($field:ident $(($arg:expr))? => $check:expr),* $(,)?) => {{1023		$(1024			if let Some($new) = $new.$field {1025				let $old = $old.$field($($arg)?);1026				let _ = $new;1027				let _ = $old;1028				$check1029			} else {1030				$new.$field = $old.$field1031			}1032		)*1033	}};1034}1035macro_rules! limit_default_clone {1036	($old:ident, $new:ident, $($field:ident $(($arg:expr))? => $check:expr),* $(,)?) => {{1037		$(1038			if let Some($new) = $new.$field.clone() {1039				let $old = $old.$field($($arg)?);1040				let _ = $new;1041				let _ = $old;1042				$check1043			} else {1044				$new.$field = $old.$field.clone()1045			}1046		)*1047	}};1048}10491050impl<T: Config> Pallet<T> {1051	/// Create new collection.1052	///1053	/// * `owner` - The owner of the collection.1054	/// * `data` - Description of the created collection.1055	/// * `flags` - Extra flags to store.1056	pub fn init_collection(1057		owner: T::CrossAccountId,1058		payer: T::CrossAccountId,1059		data: CreateCollectionData<T::AccountId>,1060		flags: CollectionFlags,1061	) -> Result<CollectionId, DispatchError> {1062		{1063			ensure!(1064				data.token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH as usize,1065				Error::<T>::CollectionTokenPrefixLimitExceeded1066			);1067		}10681069		let created_count = <CreatedCollectionCount<T>>::get()1070			.01071			.checked_add(1)1072			.ok_or(ArithmeticError::Overflow)?;1073		let destroyed_count = <DestroyedCollectionCount<T>>::get().0;1074		let id = CollectionId(created_count);10751076		// bound Total number of collections1077		ensure!(1078			created_count - destroyed_count <= COLLECTION_NUMBER_LIMIT,1079			<Error<T>>::TotalCollectionsLimitExceeded1080		);10811082		// =========10831084		let collection = Collection {1085			owner: owner.as_sub().clone(),1086			name: data.name,1087			mode: data.mode.clone(),1088			description: data.description,1089			token_prefix: data.token_prefix,1090			sponsorship: data1091				.pending_sponsor1092				.map(SponsorshipState::Unconfirmed)1093				.unwrap_or_default(),1094			limits: data1095				.limits1096				.map(|limits| Self::clamp_limits(data.mode.clone(), &Default::default(), limits))1097				.unwrap_or_else(|| Ok(CollectionLimits::default()))?,1098			permissions: data1099				.permissions1100				.map(|permissions| {1101					Self::clamp_permissions(data.mode.clone(), &Default::default(), permissions)1102				})1103				.unwrap_or_else(|| Ok(CollectionPermissions::default()))?,1104			flags,1105		};11061107		let mut collection_properties = up_data_structs::CollectionProperties::get();1108		collection_properties1109			.try_set_from_iter(data.properties.into_iter())1110			.map_err(<Error<T>>::from)?;11111112		CollectionProperties::<T>::insert(id, collection_properties);11131114		let mut token_props_permissions = PropertiesPermissionMap::new();1115		token_props_permissions1116			.try_set_from_iter(data.token_property_permissions.into_iter())1117			.map_err(<Error<T>>::from)?;11181119		CollectionPropertyPermissions::<T>::insert(id, token_props_permissions);11201121		// Take a (non-refundable) deposit of collection creation1122		{1123			let mut imbalance =1124				<<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();1125			imbalance.subsume(1126				<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(1127					&T::TreasuryAccountId::get(),1128					T::CollectionCreationPrice::get(),1129				),1130			);1131			<T as Config>::Currency::settle(1132				payer.as_sub(),1133				imbalance,1134				WithdrawReasons::TRANSFER,1135				ExistenceRequirement::KeepAlive,1136			)1137			.map_err(|_| Error::<T>::NotSufficientFounds)?;1138		}11391140		<CreatedCollectionCount<T>>::put(created_count);1141		<Pallet<T>>::deposit_event(Event::CollectionCreated(1142			id,1143			data.mode.id(),1144			owner.as_sub().clone(),1145		));1146		<PalletEvm<T>>::deposit_log(1147			erc::CollectionHelpersEvents::CollectionCreated {1148				owner: *owner.as_eth(),1149				collection_id: eth::collection_id_to_address(id),1150			}1151			.to_log(T::ContractAddress::get()),1152		);1153		<CollectionById<T>>::insert(id, collection);1154		Ok(id)1155	}11561157	/// Destroy collection.1158	///1159	/// * `collection` - Collection handler.1160	/// * `sender` - The owner or administrator of the collection.1161	pub fn destroy_collection(1162		collection: CollectionHandle<T>,1163		sender: &T::CrossAccountId,1164	) -> DispatchResult {1165		ensure!(1166			collection.limits.owner_can_destroy(),1167			<Error<T>>::NoPermission,1168		);1169		collection.check_is_owner(sender)?;11701171		let destroyed_collections = <DestroyedCollectionCount<T>>::get()1172			.01173			.checked_add(1)1174			.ok_or(ArithmeticError::Overflow)?;11751176		// =========11771178		<DestroyedCollectionCount<T>>::put(destroyed_collections);1179		<CollectionById<T>>::remove(collection.id);1180		<AdminAmount<T>>::remove(collection.id);1181		let _ = <IsAdmin<T>>::clear_prefix((collection.id,), u32::MAX, None);1182		let _ = <Allowlist<T>>::clear_prefix((collection.id,), u32::MAX, None);1183		<CollectionProperties<T>>::remove(collection.id);11841185		<Pallet<T>>::deposit_event(Event::CollectionDestroyed(collection.id));11861187		<PalletEvm<T>>::deposit_log(1188			erc::CollectionHelpersEvents::CollectionDestroyed {1189				collection_id: eth::collection_id_to_address(collection.id),1190			}1191			.to_log(T::ContractAddress::get()),1192		);1193		Ok(())1194	}11951196	/// Set collection property.1197	///1198	/// * `collection` - Collection handler.1199	/// * `sender` - The owner or administrator of the collection.1200	/// * `property` - The property to set.1201	pub fn set_collection_property(1202		collection: &CollectionHandle<T>,1203		sender: &T::CrossAccountId,1204		property: Property,1205	) -> DispatchResult {1206		collection.check_is_owner_or_admin(sender)?;12071208		CollectionProperties::<T>::try_mutate(collection.id, |properties| {1209			let property = property.clone();1210			properties.try_set(property.key, property.value)1211		})1212		.map_err(<Error<T>>::from)?;12131214		Self::deposit_event(Event::CollectionPropertySet(collection.id, property.key));1215		<PalletEvm<T>>::deposit_log(1216			erc::CollectionHelpersEvents::CollectionChanged {1217				collection_id: eth::collection_id_to_address(collection.id),1218			}1219			.to_log(T::ContractAddress::get()),1220		);12211222		Ok(())1223	}12241225	/// Set a scoped collection property, where the scope is a special prefix1226	/// prohibiting a user access to change the property directly.1227	///1228	/// * `collection_id` - ID of the collection for which the property is being set.1229	/// * `scope` - Property scope.1230	/// * `property` - The property to set.1231	pub fn set_scoped_collection_property(1232		collection_id: CollectionId,1233		scope: PropertyScope,1234		property: Property,1235	) -> DispatchResult {1236		CollectionProperties::<T>::try_mutate(collection_id, |properties| {1237			properties.try_scoped_set(scope, property.key, property.value)1238		})1239		.map_err(<Error<T>>::from)?;12401241		Ok(())1242	}12431244	/// Set scoped collection properties, where the scope is a special prefix1245	/// prohibiting a user access to change the properties directly.1246	///1247	/// * `collection_id` - ID of the collection for which the properties is being set.1248	/// * `scope` - Property scope.1249	/// * `properties` - The properties to set.1250	pub fn set_scoped_collection_properties(1251		collection_id: CollectionId,1252		scope: PropertyScope,1253		properties: impl Iterator<Item = Property>,1254	) -> DispatchResult {1255		CollectionProperties::<T>::try_mutate(collection_id, |stored_properties| {1256			stored_properties.try_scoped_set_from_iter(scope, properties)1257		})1258		.map_err(<Error<T>>::from)?;12591260		Ok(())1261	}12621263	/// Set collection properties.1264	///1265	/// * `collection` - Collection handler.1266	/// * `sender` - The owner or administrator of the collection.1267	/// * `properties` - The properties to set.1268	#[transactional]1269	pub fn set_collection_properties(1270		collection: &CollectionHandle<T>,1271		sender: &T::CrossAccountId,1272		properties: Vec<Property>,1273	) -> DispatchResult {1274		for property in properties {1275			Self::set_collection_property(collection, sender, property)?;1276		}12771278		Ok(())1279	}12801281	/// Delete collection property.1282	///1283	/// * `collection` - Collection handler.1284	/// * `sender` - The owner or administrator of the collection.1285	/// * `property` - The property to delete.1286	pub fn delete_collection_property(1287		collection: &CollectionHandle<T>,1288		sender: &T::CrossAccountId,1289		property_key: PropertyKey,1290	) -> DispatchResult {1291		collection.check_is_owner_or_admin(sender)?;12921293		CollectionProperties::<T>::try_mutate(collection.id, |properties| {1294			properties.remove(&property_key)1295		})1296		.map_err(<Error<T>>::from)?;12971298		Self::deposit_event(Event::CollectionPropertyDeleted(1299			collection.id,1300			property_key,1301		));1302		<PalletEvm<T>>::deposit_log(1303			erc::CollectionHelpersEvents::CollectionChanged {1304				collection_id: eth::collection_id_to_address(collection.id),1305			}1306			.to_log(T::ContractAddress::get()),1307		);13081309		Ok(())1310	}13111312	/// Delete collection properties.1313	///1314	/// * `collection` - Collection handler.1315	/// * `sender` - The owner or administrator of the collection.1316	/// * `properties` - The properties to delete.1317	#[transactional]1318	pub fn delete_collection_properties(1319		collection: &CollectionHandle<T>,1320		sender: &T::CrossAccountId,1321		property_keys: Vec<PropertyKey>,1322	) -> DispatchResult {1323		for key in property_keys {1324			Self::delete_collection_property(collection, sender, key)?;1325		}13261327		Ok(())1328	}13291330	/// Set collection propetry permission without any checks.1331	///1332	/// Used for migrations.1333	///1334	/// * `collection` - Collection handler.1335	/// * `property_permissions` - Property permissions.1336	pub fn set_property_permission_unchecked(1337		collection: CollectionId,1338		property_permission: PropertyKeyPermission,1339	) -> DispatchResult {1340		<CollectionPropertyPermissions<T>>::try_mutate(collection, |permissions| {1341			permissions.try_set(property_permission.key, property_permission.permission)1342		})1343		.map_err(<Error<T>>::from)?;1344		Ok(())1345	}13461347	/// Set collection property permission.1348	///1349	/// * `collection` - Collection handler.1350	/// * `sender` - The owner or administrator of the collection.1351	/// * `property_permission` - Property permission.1352	pub fn set_property_permission(1353		collection: &CollectionHandle<T>,1354		sender: &T::CrossAccountId,1355		property_permission: PropertyKeyPermission,1356	) -> DispatchResult {1357		Self::set_scoped_property_permission(1358			collection,1359			sender,1360			PropertyScope::None,1361			property_permission,1362		)1363	}13641365	/// Set collection property permission with scope.1366	///1367	/// * `collection` - Collection handler.1368	/// * `sender` - The owner or administrator of the collection.1369	/// * `scope` - Property scope.1370	/// * `property_permission` - Property permission.1371	pub fn set_scoped_property_permission(1372		collection: &CollectionHandle<T>,1373		sender: &T::CrossAccountId,1374		scope: PropertyScope,1375		property_permission: PropertyKeyPermission,1376	) -> DispatchResult {1377		collection.check_is_owner_or_admin(sender)?;13781379		let all_permissions = CollectionPropertyPermissions::<T>::get(collection.id);1380		let current_permission = all_permissions.get(&property_permission.key);1381		if matches![1382			current_permission,1383			Some(PropertyPermission { mutable: false, .. })1384		] {1385			return Err(<Error<T>>::NoPermission.into());1386		}13871388		CollectionPropertyPermissions::<T>::try_mutate(collection.id, |permissions| {1389			let property_permission = property_permission.clone();1390			permissions.try_scoped_set(1391				scope,1392				property_permission.key,1393				property_permission.permission,1394			)1395		})1396		.map_err(<Error<T>>::from)?;13971398		Self::deposit_event(Event::PropertyPermissionSet(1399			collection.id,1400			property_permission.key,1401		));1402		<PalletEvm<T>>::deposit_log(1403			erc::CollectionHelpersEvents::CollectionChanged {1404				collection_id: eth::collection_id_to_address(collection.id),1405			}1406			.to_log(T::ContractAddress::get()),1407		);14081409		Ok(())1410	}14111412	/// Set token property permission.1413	///1414	/// * `collection` - Collection handler.1415	/// * `sender` - The owner or administrator of the collection.1416	/// * `property_permissions` - Property permissions.1417	#[transactional]1418	pub fn set_token_property_permissions(1419		collection: &CollectionHandle<T>,1420		sender: &T::CrossAccountId,1421		property_permissions: Vec<PropertyKeyPermission>,1422	) -> DispatchResult {1423		Self::set_scoped_token_property_permissions(1424			collection,1425			sender,1426			PropertyScope::None,1427			property_permissions,1428		)1429	}14301431	/// Set token property permission with scope.1432	///1433	/// * `collection` - Collection handler.1434	/// * `sender` - The owner or administrator of the collection.1435	/// * `scope` - Property scope.1436	/// * `property_permissions` - Property permissions.1437	#[transactional]1438	pub fn set_scoped_token_property_permissions(1439		collection: &CollectionHandle<T>,1440		sender: &T::CrossAccountId,1441		scope: PropertyScope,1442		property_permissions: Vec<PropertyKeyPermission>,1443	) -> DispatchResult {1444		for prop_pemission in property_permissions {1445			Self::set_scoped_property_permission(collection, sender, scope, prop_pemission)?;1446		}14471448		Ok(())1449	}14501451	/// Get collection property.1452	pub fn get_collection_property(1453		collection_id: CollectionId,1454		key: &PropertyKey,1455	) -> Option<PropertyValue> {1456		Self::collection_properties(collection_id).get(key).cloned()1457	}14581459	/// Convert byte vector to property key vector.1460	pub fn bytes_keys_to_property_keys(1461		keys: Vec<Vec<u8>>,1462	) -> Result<Vec<PropertyKey>, DispatchError> {1463		keys.into_iter()1464			.map(|key| -> Result<PropertyKey, DispatchError> {1465				key.try_into()1466					.map_err(|_| <Error<T>>::PropertyKeyIsTooLong.into())1467			})1468			.collect::<Result<Vec<PropertyKey>, DispatchError>>()1469	}14701471	/// Get properties according to given keys.1472	pub fn filter_collection_properties(1473		collection_id: CollectionId,1474		keys: Option<Vec<PropertyKey>>,1475	) -> Result<Vec<Property>, DispatchError> {1476		let properties = Self::collection_properties(collection_id);14771478		let properties = keys1479			.map(|keys| {1480				keys.into_iter()1481					.filter_map(|key| {1482						properties.get(&key).map(|value| Property {1483							key,1484							value: value.clone(),1485						})1486					})1487					.collect()1488			})1489			.unwrap_or_else(|| {1490				properties1491					.into_iter()1492					.map(|(key, value)| Property { key, value })1493					.collect()1494			});14951496		Ok(properties)1497	}14981499	/// Get property permissions according to given keys.1500	pub fn filter_property_permissions(1501		collection_id: CollectionId,1502		keys: Option<Vec<PropertyKey>>,1503	) -> Result<Vec<PropertyKeyPermission>, DispatchError> {1504		let permissions = Self::property_permissions(collection_id);15051506		let key_permissions = keys1507			.map(|keys| {1508				keys.into_iter()1509					.filter_map(|key| {1510						permissions1511							.get(&key)1512							.map(|permission| PropertyKeyPermission {1513								key,1514								permission: permission.clone(),1515							})1516					})1517					.collect()1518			})1519			.unwrap_or_else(|| {1520				permissions1521					.into_iter()1522					.map(|(key, permission)| PropertyKeyPermission { key, permission })1523					.collect()1524			});15251526		Ok(key_permissions)1527	}15281529	/// Toggle `user` participation in the `collection`'s allow list.1530	/// #### Store read/writes1531	/// 1 writes1532	pub fn toggle_allowlist(1533		collection: &CollectionHandle<T>,1534		sender: &T::CrossAccountId,1535		user: &T::CrossAccountId,1536		allowed: bool,1537	) -> DispatchResult {1538		collection.check_is_owner_or_admin(sender)?;15391540		// =========15411542		if allowed {1543			<Allowlist<T>>::insert((collection.id, user), true);1544			Self::deposit_event(Event::<T>::AllowListAddressAdded(1545				collection.id,1546				user.clone(),1547			));1548		} else {1549			<Allowlist<T>>::remove((collection.id, user));1550			Self::deposit_event(Event::<T>::AllowListAddressRemoved(1551				collection.id,1552				user.clone(),1553			));1554		}15551556		<PalletEvm<T>>::deposit_log(1557			erc::CollectionHelpersEvents::CollectionChanged {1558				collection_id: eth::collection_id_to_address(collection.id),1559			}1560			.to_log(T::ContractAddress::get()),1561		);15621563		Ok(())1564	}15651566	/// Toggle `user` participation in the `collection`'s admin list.1567	/// #### Store read/writes1568	/// 2 reads, 2 writes1569	pub fn toggle_admin(1570		collection: &CollectionHandle<T>,1571		sender: &T::CrossAccountId,1572		user: &T::CrossAccountId,1573		admin: bool,1574	) -> DispatchResult {1575		collection.check_is_internal()?;1576		collection.check_is_owner(sender)?;15771578		let is_admin = <IsAdmin<T>>::get((collection.id, user));1579		if is_admin == admin {1580			if admin {1581				return Ok(());1582			} else {1583				return Err(Error::<T>::UserIsNotCollectionAdmin.into());1584			}1585		}1586		let amount = <AdminAmount<T>>::get(collection.id);15871588		// =========15891590		if admin {1591			let amount = amount1592				.checked_add(1)1593				.ok_or(<Error<T>>::CollectionAdminCountExceeded)?;1594			ensure!(1595				amount <= Self::collection_admins_limit(),1596				<Error<T>>::CollectionAdminCountExceeded,1597			);15981599			<AdminAmount<T>>::insert(collection.id, amount);1600			<IsAdmin<T>>::insert((collection.id, user), true);16011602			Self::deposit_event(Event::<T>::CollectionAdminAdded(1603				collection.id,1604				user.clone(),1605			));1606		} else {1607			<AdminAmount<T>>::insert(collection.id, amount.saturating_sub(1));1608			<IsAdmin<T>>::remove((collection.id, user));16091610			Self::deposit_event(Event::<T>::CollectionAdminRemoved(1611				collection.id,1612				user.clone(),1613			));1614		}16151616		<PalletEvm<T>>::deposit_log(1617			erc::CollectionHelpersEvents::CollectionChanged {1618				collection_id: eth::collection_id_to_address(collection.id),1619			}1620			.to_log(T::ContractAddress::get()),1621		);16221623		Ok(())1624	}16251626	/// Update collection limits.1627	pub fn update_limits(1628		user: &T::CrossAccountId,1629		collection: &mut CollectionHandle<T>,1630		new_limit: CollectionLimits,1631	) -> DispatchResult {1632		collection.check_is_internal()?;1633		collection.check_is_owner_or_admin(user)?;16341635		collection.limits =1636			Self::clamp_limits(collection.mode.clone(), &collection.limits, new_limit)?;16371638		Self::deposit_event(Event::<T>::CollectionLimitSet(collection.id));1639		<PalletEvm<T>>::deposit_log(1640			erc::CollectionHelpersEvents::CollectionChanged {1641				collection_id: eth::collection_id_to_address(collection.id),1642			}1643			.to_log(T::ContractAddress::get()),1644		);16451646		collection.save()1647	}16481649	/// Merge set fields from `new_limit` to `old_limit`.1650	fn clamp_limits(1651		mode: CollectionMode,1652		old_limit: &CollectionLimits,1653		mut new_limit: CollectionLimits,1654	) -> Result<CollectionLimits, DispatchError> {1655		let limits = old_limit;1656		limit_default!(old_limit, new_limit,1657			account_token_ownership_limit => ensure!(1658				new_limit <= MAX_TOKEN_OWNERSHIP,1659				<Error<T>>::CollectionLimitBoundsExceeded,1660			),1661			sponsored_data_size => ensure!(1662				new_limit <= CUSTOM_DATA_LIMIT,1663				<Error<T>>::CollectionLimitBoundsExceeded,1664			),16651666			sponsored_data_rate_limit => {},1667			token_limit => ensure!(1668				old_limit >= new_limit && new_limit > 0,1669				<Error<T>>::CollectionTokenLimitExceeded1670			),16711672			sponsor_transfer_timeout(match mode {1673				CollectionMode::NFT => NFT_SPONSOR_TRANSFER_TIMEOUT,1674				CollectionMode::Fungible(_) => FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,1675				CollectionMode::ReFungible => REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,1676			}) => ensure!(1677				new_limit <= MAX_SPONSOR_TIMEOUT,1678				<Error<T>>::CollectionLimitBoundsExceeded,1679			),1680			sponsor_approve_timeout => {},1681			owner_can_transfer => ensure!(1682				!limits.owner_can_transfer_instaled() ||1683				old_limit || !new_limit,1684				<Error<T>>::OwnerPermissionsCantBeReverted,1685			),1686			owner_can_destroy => ensure!(1687				old_limit || !new_limit,1688				<Error<T>>::OwnerPermissionsCantBeReverted,1689			),1690			transfers_enabled => {},1691		);1692		Ok(new_limit)1693	}16941695	/// Update collection permissions.1696	pub fn update_permissions(1697		user: &T::CrossAccountId,1698		collection: &mut CollectionHandle<T>,1699		new_permission: CollectionPermissions,1700	) -> DispatchResult {1701		collection.check_is_internal()?;1702		collection.check_is_owner_or_admin(user)?;1703		collection.permissions = Self::clamp_permissions(1704			collection.mode.clone(),1705			&collection.permissions,1706			new_permission,1707		)?;17081709		Self::deposit_event(Event::<T>::CollectionPermissionSet(collection.id));1710		<PalletEvm<T>>::deposit_log(1711			erc::CollectionHelpersEvents::CollectionChanged {1712				collection_id: eth::collection_id_to_address(collection.id),1713			}1714			.to_log(T::ContractAddress::get()),1715		);17161717		collection.save()1718	}17191720	/// Merge set fields from `new_permission` to `old_permission`.1721	fn clamp_permissions(1722		_mode: CollectionMode,1723		old_permission: &CollectionPermissions,1724		mut new_permission: CollectionPermissions,1725	) -> Result<CollectionPermissions, DispatchError> {1726		limit_default_clone!(old_permission, new_permission,1727			access => {},1728			mint_mode => {},1729			nesting => { /* todo check for permissive, if only it gets out of benchmarks */ },1730		);1731		Ok(new_permission)1732	}17331734	/// Repair possibly broken properties of a collection.1735	pub fn repair_collection(collection_id: CollectionId) -> DispatchResult {1736		CollectionProperties::<T>::mutate(collection_id, |properties| {1737			properties.recompute_consumed_space();1738		});17391740		Ok(())1741	}1742}17431744/// Indicates unsupported methods by returning [Error::UnsupportedOperation].1745#[macro_export]1746macro_rules! unsupported {1747	($runtime:path) => {1748		Err($crate::Error::<$runtime>::UnsupportedOperation.into())1749	};1750}17511752/// Return weights for various worst-case operations.1753pub trait CommonWeightInfo<CrossAccountId> {1754	/// Weight of item creation.1755	fn create_item() -> Weight;17561757	/// Weight of items creation.1758	fn create_multiple_items(amount: &[CreateItemData]) -> Weight;17591760	/// Weight of items creation.1761	fn create_multiple_items_ex(cost: &CreateItemExData<CrossAccountId>) -> Weight;17621763	/// The weight of the burning item.1764	fn burn_item() -> Weight;17651766	/// Property setting weight.1767	///1768	/// * `amount`- The number of properties to set.1769	fn set_collection_properties(amount: u32) -> Weight;17701771	/// Collection property deletion weight.1772	///1773	/// * `amount`- The number of properties to set.1774	fn delete_collection_properties(amount: u32) -> Weight;17751776	/// Token property setting weight.1777	///1778	/// * `amount`- The number of properties to set.1779	fn set_token_properties(amount: u32) -> Weight;17801781	/// Token property deletion weight.1782	///1783	/// * `amount`- The number of properties to delete.1784	fn delete_token_properties(amount: u32) -> Weight;17851786	/// Token property permissions set weight.1787	///1788	/// * `amount`- The number of property permissions to set.1789	fn set_token_property_permissions(amount: u32) -> Weight;17901791	/// Transfer price of the token or its parts.1792	fn transfer() -> Weight;17931794	/// The price of setting the permission of the operation from another user.1795	fn approve() -> Weight;17961797	/// Transfer price from another user.1798	fn transfer_from() -> Weight;17991800	/// The price of burning a token from another user.1801	fn burn_from() -> Weight;18021803	/// Differs from burn_item in case of Fungible and Refungible, as it should burn1804	/// whole users's balance.1805	///1806	/// This method shouldn't be used directly, as it doesn't count breadth price, use [burn_recursively](CommonWeightInfo::burn_recursively) instead1807	fn burn_recursively_self_raw() -> Weight;18081809	/// Cost of iterating over `amount` children while burning, without counting child burning itself.1810	///1811	/// This method shouldn't be used directly, as it doesn't count depth price, use [burn_recursively](CommonWeightInfo::burn_recursively) instead1812	fn burn_recursively_breadth_raw(amount: u32) -> Weight;18131814	/// The price of recursive burning a token.1815	///1816	/// `max_selfs` - The maximum burning weight of the token itself.1817	/// `max_breadth` - The maximum number of nested tokens to burn.1818	fn burn_recursively(max_selfs: u32, max_breadth: u32) -> Weight {1819		Self::burn_recursively_self_raw()1820			.saturating_mul(max_selfs.max(1) as u64)1821			.saturating_add(Self::burn_recursively_breadth_raw(max_breadth))1822	}18231824	/// The price of retrieving token owner1825	fn token_owner() -> Weight;18261827	/// The price of setting approval for all1828	fn set_allowance_for_all() -> Weight;18291830	/// The price of repairing an item.1831	fn force_repair_item() -> Weight;1832}18331834/// Weight info extension trait for refungible pallet.1835pub trait RefungibleExtensionsWeightInfo {1836	/// Weight of token repartition.1837	fn repartition() -> Weight;1838}18391840/// Common collection operations.1841///1842/// It wraps methods in Fungible, Nonfungible and Refungible pallets1843/// and adds weight info.1844pub trait CommonCollectionOperations<T: Config> {1845	/// Create token.1846	///1847	/// * `sender` - The user who mint the token and pays for the transaction.1848	/// * `to` - The user who will own the token.1849	/// * `data` - Token data.1850	/// * `nesting_budget` - A budget that can be spent on nesting tokens.1851	fn create_item(1852		&self,1853		sender: T::CrossAccountId,1854		to: T::CrossAccountId,1855		data: CreateItemData,1856		nesting_budget: &dyn Budget,1857	) -> DispatchResultWithPostInfo;18581859	/// Create multiple tokens.1860	///1861	/// * `sender` - The user who mint the token and pays for the transaction.1862	/// * `to` - The user who will own the token.1863	/// * `data` - Token data.1864	/// * `nesting_budget` - A budget that can be spent on nesting tokens.1865	fn create_multiple_items(1866		&self,1867		sender: T::CrossAccountId,1868		to: T::CrossAccountId,1869		data: Vec<CreateItemData>,1870		nesting_budget: &dyn Budget,1871	) -> DispatchResultWithPostInfo;18721873	/// Create multiple tokens.1874	///1875	/// * `sender` - The user who mint the token and pays for the transaction.1876	/// * `to` - The user who will own the token.1877	/// * `data` - Token data.1878	/// * `nesting_budget` - A budget that can be spent on nesting tokens.1879	fn create_multiple_items_ex(1880		&self,1881		sender: T::CrossAccountId,1882		data: CreateItemExData<T::CrossAccountId>,1883		nesting_budget: &dyn Budget,1884	) -> DispatchResultWithPostInfo;18851886	/// Burn token.1887	///1888	/// * `sender` - The user who owns the token.1889	/// * `token` - Token id that will burned.1890	/// * `amount` - The number of parts of the token that will be burned.1891	fn burn_item(1892		&self,1893		sender: T::CrossAccountId,1894		token: TokenId,1895		amount: u128,1896	) -> DispatchResultWithPostInfo;18971898	/// Burn token and all nested tokens recursievly.1899	///1900	/// * `sender` - The user who owns the token.1901	/// * `token` - Token id that will burned.1902	/// * `self_budget` - The budget that can be spent on burning tokens.1903	/// * `breadth_budget` - The budget that can be spent on burning nested tokens.1904	fn burn_item_recursively(1905		&self,1906		sender: T::CrossAccountId,1907		token: TokenId,1908		self_budget: &dyn Budget,1909		breadth_budget: &dyn Budget,1910	) -> DispatchResultWithPostInfo;19111912	/// Set collection properties.1913	///1914	/// * `sender` - Must be either the owner of the collection or its admin.1915	/// * `properties` - Properties to be set.1916	fn set_collection_properties(1917		&self,1918		sender: T::CrossAccountId,1919		properties: Vec<Property>,1920	) -> DispatchResultWithPostInfo;19211922	/// Delete collection properties.1923	///1924	/// * `sender` - Must be either the owner of the collection or its admin.1925	/// * `properties` - The properties to be removed.1926	fn delete_collection_properties(1927		&self,1928		sender: &T::CrossAccountId,1929		property_keys: Vec<PropertyKey>,1930	) -> DispatchResultWithPostInfo;19311932	/// Set token properties.1933	///1934	/// The appropriate [`PropertyPermission`] for the token property1935	/// must be set with [`Self::set_token_property_permissions`].1936	///1937	/// * `sender` - Must be either the owner of the token or its admin.1938	/// * `token_id` - The token for which the properties are being set.1939	/// * `properties` - Properties to be set.1940	/// * `budget` - Budget for setting properties.1941	fn set_token_properties(1942		&self,1943		sender: T::CrossAccountId,1944		token_id: TokenId,1945		properties: Vec<Property>,1946		budget: &dyn Budget,1947	) -> DispatchResultWithPostInfo;19481949	/// Remove token properties.1950	///1951	/// The appropriate [`PropertyPermission`] for the token property1952	/// must be set with [`Self::set_token_property_permissions`].1953	///1954	/// * `sender` - Must be either the owner of the token or its admin.1955	/// * `token_id` - The token for which the properties are being remove.1956	/// * `property_keys` - Keys to remove corresponding properties.1957	/// * `budget` - Budget for removing properties.1958	fn delete_token_properties(1959		&self,1960		sender: T::CrossAccountId,1961		token_id: TokenId,1962		property_keys: Vec<PropertyKey>,1963		budget: &dyn Budget,1964	) -> DispatchResultWithPostInfo;19651966	/// Set token property permissions.1967	///1968	/// * `sender` - Must be either the owner of the token or its admin.1969	/// * `token_id` - The token for which the properties are being set.1970	/// * `property_permissions` - Property permissions to be set.1971	/// * `budget` - Budget for setting properties.1972	fn set_token_property_permissions(1973		&self,1974		sender: &T::CrossAccountId,1975		property_permissions: Vec<PropertyKeyPermission>,1976	) -> DispatchResultWithPostInfo;19771978	/// Transfer amount of token pieces.1979	///1980	/// * `sender` - Donor user.1981	/// * `to` - Recepient user.1982	/// * `token` - The token of which parts are being sent.1983	/// * `amount` - The number of parts of the token that will be transferred.1984	/// * `budget` - The maximum budget that can be spent on the transfer.1985	fn transfer(1986		&self,1987		sender: T::CrossAccountId,1988		to: T::CrossAccountId,1989		token: TokenId,1990		amount: u128,1991		budget: &dyn Budget,1992	) -> DispatchResultWithPostInfo;19931994	/// Grant access to another account to transfer parts of the token owned by the calling user via [Self::transfer_from].1995	///1996	/// * `sender` - The user who grants access to the token.1997	/// * `spender` - The user to whom the rights are granted.1998	/// * `token` - The token to which access is granted.1999	/// * `amount` - The amount of pieces that another user can dispose of.2000	fn approve(2001		&self,2002		sender: T::CrossAccountId,2003		spender: T::CrossAccountId,2004		token: TokenId,2005		amount: u128,2006	) -> DispatchResultWithPostInfo;20072008	/// Send parts of a token owned by another user.2009	///2010	/// Before calling this method, you must grant rights to the calling user via [`Self::approve`].2011	///2012	/// * `sender` - The user who must have access to the token (see [`Self::approve`]).2013	/// * `from` - The user who owns the token.2014	/// * `to` - Recepient user.2015	/// * `token` - The token of which parts are being sent.2016	/// * `amount` - The number of parts of the token that will be transferred.2017	/// * `budget` - The maximum budget that can be spent on the transfer.2018	fn transfer_from(2019		&self,2020		sender: T::CrossAccountId,2021		from: T::CrossAccountId,2022		to: T::CrossAccountId,2023		token: TokenId,2024		amount: u128,2025		budget: &dyn Budget,2026	) -> DispatchResultWithPostInfo;20272028	/// Burn parts of a token owned by another user.2029	///2030	/// Before calling this method, you must grant rights to the calling user via [`Self::approve`].2031	///2032	/// * `sender` - The user who must have access to the token (see [`Self::approve`]).2033	/// * `from` - The user who owns the token.2034	/// * `token` - The token of which parts are being sent.2035	/// * `amount` - The number of parts of the token that will be transferred.2036	/// * `budget` - The maximum budget that can be spent on the burn.2037	fn burn_from(2038		&self,2039		sender: T::CrossAccountId,2040		from: T::CrossAccountId,2041		token: TokenId,2042		amount: u128,2043		budget: &dyn Budget,2044	) -> DispatchResultWithPostInfo;20452046	/// Check permission to nest token.2047	///2048	/// * `sender` - The user who initiated the check.2049	/// * `from` - The token that is checked for embedding.2050	/// * `under` - Token under which to check.2051	/// * `budget` - The maximum budget that can be spent on the check.2052	fn check_nesting(2053		&self,2054		sender: T::CrossAccountId,2055		from: (CollectionId, TokenId),2056		under: TokenId,2057		budget: &dyn Budget,2058	) -> DispatchResult;20592060	/// Nest one token into another.2061	///2062	/// * `under` - Token holder.2063	/// * `to_nest` - Nested token.2064	fn nest(&self, under: TokenId, to_nest: (CollectionId, TokenId));20652066	/// Unnest token.2067	///2068	/// * `under` - Token holder.2069	/// * `to_nest` - Token to unnest.2070	fn unnest(&self, under: TokenId, to_nest: (CollectionId, TokenId));20712072	/// Get all user tokens.2073	///2074	/// * `account` - Account for which you need to get tokens.2075	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId>;20762077	/// Get all the tokens in the collection.2078	fn collection_tokens(&self) -> Vec<TokenId>;20792080	/// Check if the token exists.2081	///2082	/// * `token` - Id token to check.2083	fn token_exists(&self, token: TokenId) -> bool;20842085	/// Get the id of the last minted token.2086	fn last_token_id(&self) -> TokenId;20872088	/// Get the owner of the token.2089	///2090	/// * `token` - The token for which you need to find out the owner.2091	fn token_owner(&self, token: TokenId) -> Option<T::CrossAccountId>;20922093	/// Returns 10 tokens owners in no particular order.2094	///2095	/// * `token` - The token for which you need to find out the owners.2096	fn token_owners(&self, token: TokenId) -> Vec<T::CrossAccountId>;20972098	/// Get the value of the token property by key.2099	///2100	/// * `token` - Token with the property to get.2101	/// * `key` - Property name.2102	fn token_property(&self, token_id: TokenId, key: &PropertyKey) -> Option<PropertyValue>;21032104	/// Get a set of token properties by key vector.2105	///2106	/// * `token` - Token with the property to get.2107	/// * `keys` - Vector of property keys. If this parameter is [None](sp_std::result::Result),2108	/// then all properties are returned.2109	fn token_properties(&self, token: TokenId, keys: Option<Vec<PropertyKey>>) -> Vec<Property>;21102111	/// Amount of unique collection tokens2112	fn total_supply(&self) -> u32;21132114	/// Amount of different tokens account has.2115	///2116	/// * `account` - The account for which need to get the balance.2117	fn account_balance(&self, account: T::CrossAccountId) -> u32;21182119	/// Amount of specific token account have.2120	fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128;21212122	/// Amount of token pieces2123	fn total_pieces(&self, token: TokenId) -> Option<u128>;21242125	/// Get the number of parts of the token that a trusted user can manage.2126	///2127	/// * `sender` - Trusted user.2128	/// * `spender` - Owner of the token.2129	/// * `token` - The token for which to get the value.2130	fn allowance(2131		&self,2132		sender: T::CrossAccountId,2133		spender: T::CrossAccountId,2134		token: TokenId,2135	) -> u128;21362137	/// Get extension for RFT collection.2138	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>>;21392140	/// The `operator` is allowed to transfer all tokens of the `owner` on their behalf.2141	/// * `owner` - Token owner2142	/// * `operator` - Operator2143	/// * `approve` - Should operator status be granted or revoked?2144	fn set_allowance_for_all(2145		&self,2146		owner: T::CrossAccountId,2147		operator: T::CrossAccountId,2148		approve: bool,2149	) -> DispatchResultWithPostInfo;21502151	/// Tells whether the given `owner` approves the `operator`.2152	fn allowance_for_all(&self, owner: T::CrossAccountId, operator: T::CrossAccountId) -> bool;21532154	/// Repairs a possibly broken item.2155	fn repair_item(&self, token: TokenId) -> DispatchResultWithPostInfo;2156}21572158/// Extension for RFT collection.2159pub trait RefungibleExtensions<T>2160where2161	T: Config,2162{2163	/// Change the number of parts of the token.2164	///2165	/// When the value changes down, this function is equivalent to burning parts of the token.2166	///2167	/// * `sender` - The user calling the repartition operation. Must be the owner of the token.2168	/// * `token` - The token for which you want to change the number of parts.2169	/// * `amount` - The new value of the parts of the token.2170	fn repartition(2171		&self,2172		sender: &T::CrossAccountId,2173		token: TokenId,2174		amount: u128,2175	) -> DispatchResultWithPostInfo;2176}21772178/// Merge [`DispatchResult`] with [`Weight`] into [`DispatchResultWithPostInfo`].2179///2180/// Used for [`CommonCollectionOperations`] implementations and flexible enough to do so.2181pub fn with_weight(res: DispatchResult, weight: Weight) -> DispatchResultWithPostInfo {2182	let post_info = PostDispatchInfo {2183		actual_weight: Some(weight),2184		pays_fee: Pays::Yes,2185	};2186	match res {2187		Ok(()) => Ok(post_info),2188		Err(error) => Err(DispatchErrorWithPostInfo { post_info, error }),2189	}2190}21912192impl<T: Config> From<PropertiesError> for Error<T> {2193	fn from(error: PropertiesError) -> Self {2194		match error {2195			PropertiesError::NoSpaceForProperty => Self::NoSpaceForProperty,2196			PropertiesError::PropertyLimitReached => Self::PropertyLimitReached,2197			PropertiesError::InvalidCharacterInPropertyKey => Self::InvalidCharacterInPropertyKey,2198			PropertiesError::PropertyKeyIsTooLong => Self::PropertyKeyIsTooLong,2199			PropertiesError::EmptyPropertyKey => Self::EmptyPropertyKey,2200		}2201	}2202}