git.delta.rocks / unique-network / refs/commits / 6d28dd8067cd

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 scouped collection property.1226	///1227	/// * `collection_id` - ID of the collection for which the property is being set.1228	/// * `scope` - Property scope.1229	/// * `property` - The property to set.1230	pub fn set_scoped_collection_property(1231		collection_id: CollectionId,1232		scope: PropertyScope,1233		property: Property,1234	) -> DispatchResult {1235		CollectionProperties::<T>::try_mutate(collection_id, |properties| {1236			properties.try_scoped_set(scope, property.key, property.value)1237		})1238		.map_err(<Error<T>>::from)?;12391240		Ok(())1241	}12421243	/// Set scouped collection properties.1244	///1245	/// * `collection_id` - ID of the collection for which the properties is being set.1246	/// * `scope` - Property scope.1247	/// * `properties` - The properties to set.1248	pub fn set_scoped_collection_properties(1249		collection_id: CollectionId,1250		scope: PropertyScope,1251		properties: impl Iterator<Item = Property>,1252	) -> DispatchResult {1253		CollectionProperties::<T>::try_mutate(collection_id, |stored_properties| {1254			stored_properties.try_scoped_set_from_iter(scope, properties)1255		})1256		.map_err(<Error<T>>::from)?;12571258		Ok(())1259	}12601261	/// Set collection properties.1262	///1263	/// * `collection` - Collection handler.1264	/// * `sender` - The owner or administrator of the collection.1265	/// * `properties` - The properties to set.1266	#[transactional]1267	pub fn set_collection_properties(1268		collection: &CollectionHandle<T>,1269		sender: &T::CrossAccountId,1270		properties: Vec<Property>,1271	) -> DispatchResult {1272		for property in properties {1273			Self::set_collection_property(collection, sender, property)?;1274		}12751276		Ok(())1277	}12781279	/// Delete collection property.1280	///1281	/// * `collection` - Collection handler.1282	/// * `sender` - The owner or administrator of the collection.1283	/// * `property` - The property to delete.1284	pub fn delete_collection_property(1285		collection: &CollectionHandle<T>,1286		sender: &T::CrossAccountId,1287		property_key: PropertyKey,1288	) -> DispatchResult {1289		collection.check_is_owner_or_admin(sender)?;12901291		CollectionProperties::<T>::try_mutate(collection.id, |properties| {1292			properties.remove(&property_key)1293		})1294		.map_err(<Error<T>>::from)?;12951296		Self::deposit_event(Event::CollectionPropertyDeleted(1297			collection.id,1298			property_key,1299		));1300		<PalletEvm<T>>::deposit_log(1301			erc::CollectionHelpersEvents::CollectionChanged {1302				collection_id: eth::collection_id_to_address(collection.id),1303			}1304			.to_log(T::ContractAddress::get()),1305		);13061307		Ok(())1308	}13091310	/// Delete collection properties.1311	///1312	/// * `collection` - Collection handler.1313	/// * `sender` - The owner or administrator of the collection.1314	/// * `properties` - The properties to delete.1315	#[transactional]1316	pub fn delete_collection_properties(1317		collection: &CollectionHandle<T>,1318		sender: &T::CrossAccountId,1319		property_keys: Vec<PropertyKey>,1320	) -> DispatchResult {1321		for key in property_keys {1322			Self::delete_collection_property(collection, sender, key)?;1323		}13241325		Ok(())1326	}13271328	/// Set collection propetry permission without any checks.1329	///1330	/// Used for migrations.1331	///1332	/// * `collection` - Collection handler.1333	/// * `property_permissions` - Property permissions.1334	pub fn set_property_permission_unchecked(1335		collection: CollectionId,1336		property_permission: PropertyKeyPermission,1337	) -> DispatchResult {1338		<CollectionPropertyPermissions<T>>::try_mutate(collection, |permissions| {1339			permissions.try_set(property_permission.key, property_permission.permission)1340		})1341		.map_err(<Error<T>>::from)?;1342		Ok(())1343	}13441345	/// Set collection property permission.1346	///1347	/// * `collection` - Collection handler.1348	/// * `sender` - The owner or administrator of the collection.1349	/// * `property_permission` - Property permission.1350	pub fn set_property_permission(1351		collection: &CollectionHandle<T>,1352		sender: &T::CrossAccountId,1353		property_permission: PropertyKeyPermission,1354	) -> DispatchResult {1355		Self::set_scoped_property_permission(1356			collection,1357			sender,1358			PropertyScope::None,1359			property_permission,1360		)1361	}13621363	/// Set collection property permission with scope.1364	///1365	/// * `collection` - Collection handler.1366	/// * `sender` - The owner or administrator of the collection.1367	/// * `scope` - Property scope.1368	/// * `property_permission` - Property permission.1369	pub fn set_scoped_property_permission(1370		collection: &CollectionHandle<T>,1371		sender: &T::CrossAccountId,1372		scope: PropertyScope,1373		property_permission: PropertyKeyPermission,1374	) -> DispatchResult {1375		collection.check_is_owner_or_admin(sender)?;13761377		let all_permissions = CollectionPropertyPermissions::<T>::get(collection.id);1378		let current_permission = all_permissions.get(&property_permission.key);1379		if matches![1380			current_permission,1381			Some(PropertyPermission { mutable: false, .. })1382		] {1383			return Err(<Error<T>>::NoPermission.into());1384		}13851386		CollectionPropertyPermissions::<T>::try_mutate(collection.id, |permissions| {1387			let property_permission = property_permission.clone();1388			permissions.try_scoped_set(1389				scope,1390				property_permission.key,1391				property_permission.permission,1392			)1393		})1394		.map_err(<Error<T>>::from)?;13951396		Self::deposit_event(Event::PropertyPermissionSet(1397			collection.id,1398			property_permission.key,1399		));1400		<PalletEvm<T>>::deposit_log(1401			erc::CollectionHelpersEvents::CollectionChanged {1402				collection_id: eth::collection_id_to_address(collection.id),1403			}1404			.to_log(T::ContractAddress::get()),1405		);14061407		Ok(())1408	}14091410	/// Set token property permission.1411	///1412	/// * `collection` - Collection handler.1413	/// * `sender` - The owner or administrator of the collection.1414	/// * `property_permissions` - Property permissions.1415	#[transactional]1416	pub fn set_token_property_permissions(1417		collection: &CollectionHandle<T>,1418		sender: &T::CrossAccountId,1419		property_permissions: Vec<PropertyKeyPermission>,1420	) -> DispatchResult {1421		Self::set_scoped_token_property_permissions(1422			collection,1423			sender,1424			PropertyScope::None,1425			property_permissions,1426		)1427	}14281429	/// Set token property permission with scope.1430	///1431	/// * `collection` - Collection handler.1432	/// * `sender` - The owner or administrator of the collection.1433	/// * `scope` - Property scope.1434	/// * `property_permissions` - Property permissions.1435	#[transactional]1436	pub fn set_scoped_token_property_permissions(1437		collection: &CollectionHandle<T>,1438		sender: &T::CrossAccountId,1439		scope: PropertyScope,1440		property_permissions: Vec<PropertyKeyPermission>,1441	) -> DispatchResult {1442		for prop_pemission in property_permissions {1443			Self::set_scoped_property_permission(collection, sender, scope, prop_pemission)?;1444		}14451446		Ok(())1447	}14481449	/// Get collection property.1450	pub fn get_collection_property(1451		collection_id: CollectionId,1452		key: &PropertyKey,1453	) -> Option<PropertyValue> {1454		Self::collection_properties(collection_id).get(key).cloned()1455	}14561457	/// Convert byte vector to property key vector.1458	pub fn bytes_keys_to_property_keys(1459		keys: Vec<Vec<u8>>,1460	) -> Result<Vec<PropertyKey>, DispatchError> {1461		keys.into_iter()1462			.map(|key| -> Result<PropertyKey, DispatchError> {1463				key.try_into()1464					.map_err(|_| <Error<T>>::PropertyKeyIsTooLong.into())1465			})1466			.collect::<Result<Vec<PropertyKey>, DispatchError>>()1467	}14681469	/// Get properties according to given keys.1470	pub fn filter_collection_properties(1471		collection_id: CollectionId,1472		keys: Option<Vec<PropertyKey>>,1473	) -> Result<Vec<Property>, DispatchError> {1474		let properties = Self::collection_properties(collection_id);14751476		let properties = keys1477			.map(|keys| {1478				keys.into_iter()1479					.filter_map(|key| {1480						properties.get(&key).map(|value| Property {1481							key,1482							value: value.clone(),1483						})1484					})1485					.collect()1486			})1487			.unwrap_or_else(|| {1488				properties1489					.into_iter()1490					.map(|(key, value)| Property { key, value })1491					.collect()1492			});14931494		Ok(properties)1495	}14961497	/// Get property permissions according to given keys.1498	pub fn filter_property_permissions(1499		collection_id: CollectionId,1500		keys: Option<Vec<PropertyKey>>,1501	) -> Result<Vec<PropertyKeyPermission>, DispatchError> {1502		let permissions = Self::property_permissions(collection_id);15031504		let key_permissions = keys1505			.map(|keys| {1506				keys.into_iter()1507					.filter_map(|key| {1508						permissions1509							.get(&key)1510							.map(|permission| PropertyKeyPermission {1511								key,1512								permission: permission.clone(),1513							})1514					})1515					.collect()1516			})1517			.unwrap_or_else(|| {1518				permissions1519					.into_iter()1520					.map(|(key, permission)| PropertyKeyPermission { key, permission })1521					.collect()1522			});15231524		Ok(key_permissions)1525	}15261527	/// Toggle `user` participation in the `collection`'s allow list.1528	/// #### Store read/writes1529	/// 1 writes1530	pub fn toggle_allowlist(1531		collection: &CollectionHandle<T>,1532		sender: &T::CrossAccountId,1533		user: &T::CrossAccountId,1534		allowed: bool,1535	) -> DispatchResult {1536		collection.check_is_owner_or_admin(sender)?;15371538		// =========15391540		if allowed {1541			<Allowlist<T>>::insert((collection.id, user), true);1542			Self::deposit_event(Event::<T>::AllowListAddressAdded(1543				collection.id,1544				user.clone(),1545			));1546		} else {1547			<Allowlist<T>>::remove((collection.id, user));1548			Self::deposit_event(Event::<T>::AllowListAddressRemoved(1549				collection.id,1550				user.clone(),1551			));1552		}15531554		<PalletEvm<T>>::deposit_log(1555			erc::CollectionHelpersEvents::CollectionChanged {1556				collection_id: eth::collection_id_to_address(collection.id),1557			}1558			.to_log(T::ContractAddress::get()),1559		);15601561		Ok(())1562	}15631564	/// Toggle `user` participation in the `collection`'s admin list.1565	/// #### Store read/writes1566	/// 2 reads, 2 writes1567	pub fn toggle_admin(1568		collection: &CollectionHandle<T>,1569		sender: &T::CrossAccountId,1570		user: &T::CrossAccountId,1571		admin: bool,1572	) -> DispatchResult {1573		collection.check_is_internal()?;1574		collection.check_is_owner(sender)?;15751576		let is_admin = <IsAdmin<T>>::get((collection.id, user));1577		if is_admin == admin {1578			if admin {1579				return Ok(());1580			} else {1581				return Err(Error::<T>::UserIsNotCollectionAdmin.into());1582			}1583		}1584		let amount = <AdminAmount<T>>::get(collection.id);15851586		// =========15871588		if admin {1589			let amount = amount1590				.checked_add(1)1591				.ok_or(<Error<T>>::CollectionAdminCountExceeded)?;1592			ensure!(1593				amount <= Self::collection_admins_limit(),1594				<Error<T>>::CollectionAdminCountExceeded,1595			);15961597			<AdminAmount<T>>::insert(collection.id, amount);1598			<IsAdmin<T>>::insert((collection.id, user), true);15991600			Self::deposit_event(Event::<T>::CollectionAdminAdded(1601				collection.id,1602				user.clone(),1603			));1604		} else {1605			<AdminAmount<T>>::insert(collection.id, amount.saturating_sub(1));1606			<IsAdmin<T>>::remove((collection.id, user));16071608			Self::deposit_event(Event::<T>::CollectionAdminRemoved(1609				collection.id,1610				user.clone(),1611			));1612		}16131614		<PalletEvm<T>>::deposit_log(1615			erc::CollectionHelpersEvents::CollectionChanged {1616				collection_id: eth::collection_id_to_address(collection.id),1617			}1618			.to_log(T::ContractAddress::get()),1619		);16201621		Ok(())1622	}16231624	/// Update collection limits.1625	pub fn update_limits(1626		user: &T::CrossAccountId,1627		collection: &mut CollectionHandle<T>,1628		new_limit: CollectionLimits,1629	) -> DispatchResult {1630		collection.check_is_internal()?;1631		collection.check_is_owner_or_admin(user)?;16321633		collection.limits =1634			Self::clamp_limits(collection.mode.clone(), &collection.limits, new_limit)?;16351636		Self::deposit_event(Event::<T>::CollectionLimitSet(collection.id));1637		<PalletEvm<T>>::deposit_log(1638			erc::CollectionHelpersEvents::CollectionChanged {1639				collection_id: eth::collection_id_to_address(collection.id),1640			}1641			.to_log(T::ContractAddress::get()),1642		);16431644		collection.save()1645	}16461647	/// Merge set fields from `new_limit` to `old_limit`.1648	fn clamp_limits(1649		mode: CollectionMode,1650		old_limit: &CollectionLimits,1651		mut new_limit: CollectionLimits,1652	) -> Result<CollectionLimits, DispatchError> {1653		let limits = old_limit;1654		limit_default!(old_limit, new_limit,1655			account_token_ownership_limit => ensure!(1656				new_limit <= MAX_TOKEN_OWNERSHIP,1657				<Error<T>>::CollectionLimitBoundsExceeded,1658			),1659			sponsored_data_size => ensure!(1660				new_limit <= CUSTOM_DATA_LIMIT,1661				<Error<T>>::CollectionLimitBoundsExceeded,1662			),16631664			sponsored_data_rate_limit => {},1665			token_limit => ensure!(1666				old_limit >= new_limit && new_limit > 0,1667				<Error<T>>::CollectionTokenLimitExceeded1668			),16691670			sponsor_transfer_timeout(match mode {1671				CollectionMode::NFT => NFT_SPONSOR_TRANSFER_TIMEOUT,1672				CollectionMode::Fungible(_) => FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,1673				CollectionMode::ReFungible => REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,1674			}) => ensure!(1675				new_limit <= MAX_SPONSOR_TIMEOUT,1676				<Error<T>>::CollectionLimitBoundsExceeded,1677			),1678			sponsor_approve_timeout => {},1679			owner_can_transfer => ensure!(1680				!limits.owner_can_transfer_instaled() ||1681				old_limit || !new_limit,1682				<Error<T>>::OwnerPermissionsCantBeReverted,1683			),1684			owner_can_destroy => ensure!(1685				old_limit || !new_limit,1686				<Error<T>>::OwnerPermissionsCantBeReverted,1687			),1688			transfers_enabled => {},1689		);1690		Ok(new_limit)1691	}16921693	/// Update collection permissions.1694	pub fn update_permissions(1695		user: &T::CrossAccountId,1696		collection: &mut CollectionHandle<T>,1697		new_permission: CollectionPermissions,1698	) -> DispatchResult {1699		collection.check_is_internal()?;1700		collection.check_is_owner_or_admin(user)?;1701		collection.permissions = Self::clamp_permissions(1702			collection.mode.clone(),1703			&collection.permissions,1704			new_permission,1705		)?;17061707		Self::deposit_event(Event::<T>::CollectionPermissionSet(collection.id));1708		<PalletEvm<T>>::deposit_log(1709			erc::CollectionHelpersEvents::CollectionChanged {1710				collection_id: eth::collection_id_to_address(collection.id),1711			}1712			.to_log(T::ContractAddress::get()),1713		);17141715		collection.save()1716	}17171718	/// Merge set fields from `new_permission` to `old_permission`.1719	fn clamp_permissions(1720		_mode: CollectionMode,1721		old_permission: &CollectionPermissions,1722		mut new_permission: CollectionPermissions,1723	) -> Result<CollectionPermissions, DispatchError> {1724		limit_default_clone!(old_permission, new_permission,1725			access => {},1726			mint_mode => {},1727			nesting => { /* todo check for permissive, if only it gets out of benchmarks */ },1728		);1729		Ok(new_permission)1730	}1731}17321733/// Indicates unsupported methods by returning [Error::UnsupportedOperation].1734#[macro_export]1735macro_rules! unsupported {1736	($runtime:path) => {1737		Err($crate::Error::<$runtime>::UnsupportedOperation.into())1738	};1739}17401741/// Return weights for various worst-case operations.1742pub trait CommonWeightInfo<CrossAccountId> {1743	/// Weight of item creation.1744	fn create_item() -> Weight;17451746	/// Weight of items creation.1747	fn create_multiple_items(amount: &[CreateItemData]) -> Weight;17481749	/// Weight of items creation.1750	fn create_multiple_items_ex(cost: &CreateItemExData<CrossAccountId>) -> Weight;17511752	/// The weight of the burning item.1753	fn burn_item() -> Weight;17541755	/// Property setting weight.1756	///1757	/// * `amount`- The number of properties to set.1758	fn set_collection_properties(amount: u32) -> Weight;17591760	/// Collection property deletion weight.1761	///1762	/// * `amount`- The number of properties to set.1763	fn delete_collection_properties(amount: u32) -> Weight;17641765	/// Token property setting weight.1766	///1767	/// * `amount`- The number of properties to set.1768	fn set_token_properties(amount: u32) -> Weight;17691770	/// Token property deletion weight.1771	///1772	/// * `amount`- The number of properties to delete.1773	fn delete_token_properties(amount: u32) -> Weight;17741775	/// Token property permissions set weight.1776	///1777	/// * `amount`- The number of property permissions to set.1778	fn set_token_property_permissions(amount: u32) -> Weight;17791780	/// Transfer price of the token or its parts.1781	fn transfer() -> Weight;17821783	/// The price of setting the permission of the operation from another user.1784	fn approve() -> Weight;17851786	/// Transfer price from another user.1787	fn transfer_from() -> Weight;17881789	/// The price of burning a token from another user.1790	fn burn_from() -> Weight;17911792	/// Differs from burn_item in case of Fungible and Refungible, as it should burn1793	/// whole users's balance.1794	///1795	/// This method shouldn't be used directly, as it doesn't count breadth price, use [burn_recursively](CommonWeightInfo::burn_recursively) instead1796	fn burn_recursively_self_raw() -> Weight;17971798	/// Cost of iterating over `amount` children while burning, without counting child burning itself.1799	///1800	/// This method shouldn't be used directly, as it doesn't count depth price, use [burn_recursively](CommonWeightInfo::burn_recursively) instead1801	fn burn_recursively_breadth_raw(amount: u32) -> Weight;18021803	/// The price of recursive burning a token.1804	///1805	/// `max_selfs` - The maximum burning weight of the token itself.1806	/// `max_breadth` - The maximum number of nested tokens to burn.1807	fn burn_recursively(max_selfs: u32, max_breadth: u32) -> Weight {1808		Self::burn_recursively_self_raw()1809			.saturating_mul(max_selfs.max(1) as u64)1810			.saturating_add(Self::burn_recursively_breadth_raw(max_breadth))1811	}18121813	/// The price of retrieving token owner1814	fn token_owner() -> Weight;18151816	/// The price of setting approval for all1817	fn set_allowance_for_all() -> Weight;18181819	/// The price of repairing an item.1820	fn repair_item() -> Weight;1821}18221823/// Weight info extension trait for refungible pallet.1824pub trait RefungibleExtensionsWeightInfo {1825	/// Weight of token repartition.1826	fn repartition() -> Weight;1827}18281829/// Common collection operations.1830///1831/// It wraps methods in Fungible, Nonfungible and Refungible pallets1832/// and adds weight info.1833pub trait CommonCollectionOperations<T: Config> {1834	/// Create token.1835	///1836	/// * `sender` - The user who mint the token and pays for the transaction.1837	/// * `to` - The user who will own the token.1838	/// * `data` - Token data.1839	/// * `nesting_budget` - A budget that can be spent on nesting tokens.1840	fn create_item(1841		&self,1842		sender: T::CrossAccountId,1843		to: T::CrossAccountId,1844		data: CreateItemData,1845		nesting_budget: &dyn Budget,1846	) -> DispatchResultWithPostInfo;18471848	/// Create multiple tokens.1849	///1850	/// * `sender` - The user who mint the token and pays for the transaction.1851	/// * `to` - The user who will own the token.1852	/// * `data` - Token data.1853	/// * `nesting_budget` - A budget that can be spent on nesting tokens.1854	fn create_multiple_items(1855		&self,1856		sender: T::CrossAccountId,1857		to: T::CrossAccountId,1858		data: Vec<CreateItemData>,1859		nesting_budget: &dyn Budget,1860	) -> DispatchResultWithPostInfo;18611862	/// Create multiple tokens.1863	///1864	/// * `sender` - The user who mint the token and pays for the transaction.1865	/// * `to` - The user who will own the token.1866	/// * `data` - Token data.1867	/// * `nesting_budget` - A budget that can be spent on nesting tokens.1868	fn create_multiple_items_ex(1869		&self,1870		sender: T::CrossAccountId,1871		data: CreateItemExData<T::CrossAccountId>,1872		nesting_budget: &dyn Budget,1873	) -> DispatchResultWithPostInfo;18741875	/// Burn token.1876	///1877	/// * `sender` - The user who owns the token.1878	/// * `token` - Token id that will burned.1879	/// * `amount` - The number of parts of the token that will be burned.1880	fn burn_item(1881		&self,1882		sender: T::CrossAccountId,1883		token: TokenId,1884		amount: u128,1885	) -> DispatchResultWithPostInfo;18861887	/// Burn token and all nested tokens recursievly.1888	///1889	/// * `sender` - The user who owns the token.1890	/// * `token` - Token id that will burned.1891	/// * `self_budget` - The budget that can be spent on burning tokens.1892	/// * `breadth_budget` - The budget that can be spent on burning nested tokens.1893	fn burn_item_recursively(1894		&self,1895		sender: T::CrossAccountId,1896		token: TokenId,1897		self_budget: &dyn Budget,1898		breadth_budget: &dyn Budget,1899	) -> DispatchResultWithPostInfo;19001901	/// Set collection properties.1902	///1903	/// * `sender` - Must be either the owner of the collection or its admin.1904	/// * `properties` - Properties to be set.1905	fn set_collection_properties(1906		&self,1907		sender: T::CrossAccountId,1908		properties: Vec<Property>,1909	) -> DispatchResultWithPostInfo;19101911	/// Delete collection properties.1912	///1913	/// * `sender` - Must be either the owner of the collection or its admin.1914	/// * `properties` - The properties to be removed.1915	fn delete_collection_properties(1916		&self,1917		sender: &T::CrossAccountId,1918		property_keys: Vec<PropertyKey>,1919	) -> DispatchResultWithPostInfo;19201921	/// Set token properties.1922	///1923	/// The appropriate [`PropertyPermission`] for the token property1924	/// must be set with [`Self::set_token_property_permissions`].1925	///1926	/// * `sender` - Must be either the owner of the token or its admin.1927	/// * `token_id` - The token for which the properties are being set.1928	/// * `properties` - Properties to be set.1929	/// * `budget` - Budget for setting properties.1930	fn set_token_properties(1931		&self,1932		sender: T::CrossAccountId,1933		token_id: TokenId,1934		properties: Vec<Property>,1935		budget: &dyn Budget,1936	) -> DispatchResultWithPostInfo;19371938	/// Remove token properties.1939	///1940	/// The appropriate [`PropertyPermission`] for the token property1941	/// must be set with [`Self::set_token_property_permissions`].1942	///1943	/// * `sender` - Must be either the owner of the token or its admin.1944	/// * `token_id` - The token for which the properties are being remove.1945	/// * `property_keys` - Keys to remove corresponding properties.1946	/// * `budget` - Budget for removing properties.1947	fn delete_token_properties(1948		&self,1949		sender: T::CrossAccountId,1950		token_id: TokenId,1951		property_keys: Vec<PropertyKey>,1952		budget: &dyn Budget,1953	) -> DispatchResultWithPostInfo;19541955	/// Set token property permissions.1956	///1957	/// * `sender` - Must be either the owner of the token or its admin.1958	/// * `token_id` - The token for which the properties are being set.1959	/// * `property_permissions` - Property permissions to be set.1960	/// * `budget` - Budget for setting properties.1961	fn set_token_property_permissions(1962		&self,1963		sender: &T::CrossAccountId,1964		property_permissions: Vec<PropertyKeyPermission>,1965	) -> DispatchResultWithPostInfo;19661967	/// Transfer amount of token pieces.1968	///1969	/// * `sender` - Donor user.1970	/// * `to` - Recepient user.1971	/// * `token` - The token of which parts are being sent.1972	/// * `amount` - The number of parts of the token that will be transferred.1973	/// * `budget` - The maximum budget that can be spent on the transfer.1974	fn transfer(1975		&self,1976		sender: T::CrossAccountId,1977		to: T::CrossAccountId,1978		token: TokenId,1979		amount: u128,1980		budget: &dyn Budget,1981	) -> DispatchResultWithPostInfo;19821983	/// Grant access to another account to transfer parts of the token owned by the calling user via [Self::transfer_from].1984	///1985	/// * `sender` - The user who grants access to the token.1986	/// * `spender` - The user to whom the rights are granted.1987	/// * `token` - The token to which access is granted.1988	/// * `amount` - The amount of pieces that another user can dispose of.1989	fn approve(1990		&self,1991		sender: T::CrossAccountId,1992		spender: T::CrossAccountId,1993		token: TokenId,1994		amount: u128,1995	) -> DispatchResultWithPostInfo;19961997	/// Send parts of a token owned by another user.1998	///1999	/// Before calling this method, you must grant rights to the calling user via [`Self::approve`].2000	///2001	/// * `sender` - The user who must have access to the token (see [`Self::approve`]).2002	/// * `from` - The user who owns the token.2003	/// * `to` - Recepient user.2004	/// * `token` - The token of which parts are being sent.2005	/// * `amount` - The number of parts of the token that will be transferred.2006	/// * `budget` - The maximum budget that can be spent on the transfer.2007	fn transfer_from(2008		&self,2009		sender: T::CrossAccountId,2010		from: T::CrossAccountId,2011		to: T::CrossAccountId,2012		token: TokenId,2013		amount: u128,2014		budget: &dyn Budget,2015	) -> DispatchResultWithPostInfo;20162017	/// Burn parts of a token owned by another user.2018	///2019	/// Before calling this method, you must grant rights to the calling user via [`Self::approve`].2020	///2021	/// * `sender` - The user who must have access to the token (see [`Self::approve`]).2022	/// * `from` - The user who owns the token.2023	/// * `token` - The token of which parts are being sent.2024	/// * `amount` - The number of parts of the token that will be transferred.2025	/// * `budget` - The maximum budget that can be spent on the burn.2026	fn burn_from(2027		&self,2028		sender: T::CrossAccountId,2029		from: T::CrossAccountId,2030		token: TokenId,2031		amount: u128,2032		budget: &dyn Budget,2033	) -> DispatchResultWithPostInfo;20342035	/// Check permission to nest token.2036	///2037	/// * `sender` - The user who initiated the check.2038	/// * `from` - The token that is checked for embedding.2039	/// * `under` - Token under which to check.2040	/// * `budget` - The maximum budget that can be spent on the check.2041	fn check_nesting(2042		&self,2043		sender: T::CrossAccountId,2044		from: (CollectionId, TokenId),2045		under: TokenId,2046		budget: &dyn Budget,2047	) -> DispatchResult;20482049	/// Nest one token into another.2050	///2051	/// * `under` - Token holder.2052	/// * `to_nest` - Nested token.2053	fn nest(&self, under: TokenId, to_nest: (CollectionId, TokenId));20542055	/// Unnest token.2056	///2057	/// * `under` - Token holder.2058	/// * `to_nest` - Token to unnest.2059	fn unnest(&self, under: TokenId, to_nest: (CollectionId, TokenId));20602061	/// Get all user tokens.2062	///2063	/// * `account` - Account for which you need to get tokens.2064	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId>;20652066	/// Get all the tokens in the collection.2067	fn collection_tokens(&self) -> Vec<TokenId>;20682069	/// Check if the token exists.2070	///2071	/// * `token` - Id token to check.2072	fn token_exists(&self, token: TokenId) -> bool;20732074	/// Get the id of the last minted token.2075	fn last_token_id(&self) -> TokenId;20762077	/// Get the owner of the token.2078	///2079	/// * `token` - The token for which you need to find out the owner.2080	fn token_owner(&self, token: TokenId) -> Option<T::CrossAccountId>;20812082	/// Returns 10 tokens owners in no particular order.2083	///2084	/// * `token` - The token for which you need to find out the owners.2085	fn token_owners(&self, token: TokenId) -> Vec<T::CrossAccountId>;20862087	/// Get the value of the token property by key.2088	///2089	/// * `token` - Token with the property to get.2090	/// * `key` - Property name.2091	fn token_property(&self, token_id: TokenId, key: &PropertyKey) -> Option<PropertyValue>;20922093	/// Get a set of token properties by key vector.2094	///2095	/// * `token` - Token with the property to get.2096	/// * `keys` - Vector of property keys. If this parameter is [None](sp_std::result::Result),2097	/// then all properties are returned.2098	fn token_properties(&self, token: TokenId, keys: Option<Vec<PropertyKey>>) -> Vec<Property>;20992100	/// Amount of unique collection tokens2101	fn total_supply(&self) -> u32;21022103	/// Amount of different tokens account has.2104	///2105	/// * `account` - The account for which need to get the balance.2106	fn account_balance(&self, account: T::CrossAccountId) -> u32;21072108	/// Amount of specific token account have.2109	fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128;21102111	/// Amount of token pieces2112	fn total_pieces(&self, token: TokenId) -> Option<u128>;21132114	/// Get the number of parts of the token that a trusted user can manage.2115	///2116	/// * `sender` - Trusted user.2117	/// * `spender` - Owner of the token.2118	/// * `token` - The token for which to get the value.2119	fn allowance(2120		&self,2121		sender: T::CrossAccountId,2122		spender: T::CrossAccountId,2123		token: TokenId,2124	) -> u128;21252126	/// Get extension for RFT collection.2127	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>>;21282129	/// The `operator` is allowed to transfer all tokens of the `owner` on their behalf.2130	/// * `owner` - Token owner2131	/// * `operator` - Operator2132	/// * `approve` - Should operator status be granted or revoked?2133	fn set_allowance_for_all(2134		&self,2135		owner: T::CrossAccountId,2136		operator: T::CrossAccountId,2137		approve: bool,2138	) -> DispatchResultWithPostInfo;21392140	/// Tells whether the given `owner` approves the `operator`.2141	fn allowance_for_all(&self, owner: T::CrossAccountId, operator: T::CrossAccountId) -> bool;21422143	/// Repairs a possibly broken item.2144	fn repair_item(&self, token: TokenId) -> DispatchResultWithPostInfo;2145}21462147/// Extension for RFT collection.2148pub trait RefungibleExtensions<T>2149where2150	T: Config,2151{2152	/// Change the number of parts of the token.2153	///2154	/// When the value changes down, this function is equivalent to burning parts of the token.2155	///2156	/// * `sender` - The user calling the repartition operation. Must be the owner of the token.2157	/// * `token` - The token for which you want to change the number of parts.2158	/// * `amount` - The new value of the parts of the token.2159	fn repartition(2160		&self,2161		sender: &T::CrossAccountId,2162		token: TokenId,2163		amount: u128,2164	) -> DispatchResultWithPostInfo;2165}21662167/// Merge [`DispatchResult`] with [`Weight`] into [`DispatchResultWithPostInfo`].2168///2169/// Used for [`CommonCollectionOperations`] implementations and flexible enough to do so.2170pub fn with_weight(res: DispatchResult, weight: Weight) -> DispatchResultWithPostInfo {2171	let post_info = PostDispatchInfo {2172		actual_weight: Some(weight),2173		pays_fee: Pays::Yes,2174	};2175	match res {2176		Ok(()) => Ok(post_info),2177		Err(error) => Err(DispatchErrorWithPostInfo { post_info, error }),2178	}2179}21802181impl<T: Config> From<PropertiesError> for Error<T> {2182	fn from(error: PropertiesError) -> Self {2183		match error {2184			PropertiesError::NoSpaceForProperty => Self::NoSpaceForProperty,2185			PropertiesError::PropertyLimitReached => Self::PropertyLimitReached,2186			PropertiesError::InvalidCharacterInPropertyKey => Self::InvalidCharacterInPropertyKey,2187			PropertiesError::PropertyKeyIsTooLong => Self::PropertyKeyIsTooLong,2188			PropertiesError::EmptyPropertyKey => Self::EmptyPropertyKey,2189		}2190	}2191}