git.delta.rocks / unique-network / refs/commits / 192d143b298f

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};118use up_pov_estimate_rpc::PovInfo;119120pub use pallet::*;121use sp_core::H160;122use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};123#[cfg(feature = "runtime-benchmarks")]124pub mod benchmarking;125pub mod dispatch;126pub mod erc;127pub mod eth;128pub mod weights;129130/// Weight info.131pub type SelfWeightOf<T> = <T as Config>::WeightInfo;132133/// Collection handle contains information about collection data and id.134/// Also provides functionality to count consumed gas.135///136/// CollectionHandle is used as a generic wrapper for collections of all types.137/// It allows to perform common operations and queries on any collection type,138/// both completely general for all, as well as their respective implementations of [`CommonCollectionOperations`].139#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]140pub struct CollectionHandle<T: Config> {141	/// Collection id142	pub id: CollectionId,143	collection: Collection<T::AccountId>,144	/// Substrate recorder for counting consumed gas145	pub recorder: SubstrateRecorder<T>,146}147148impl<T: Config> WithRecorder<T> for CollectionHandle<T> {149	fn recorder(&self) -> &SubstrateRecorder<T> {150		&self.recorder151	}152	fn into_recorder(self) -> SubstrateRecorder<T> {153		self.recorder154	}155}156157impl<T: Config> CollectionHandle<T> {158	/// Same as [CollectionHandle::new] but with an explicit gas limit.159	pub fn new_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {160		<CollectionById<T>>::get(id).map(|collection| Self {161			id,162			collection,163			recorder: SubstrateRecorder::new(gas_limit),164		})165	}166167	/// Same as [CollectionHandle::new] but with an existed [`SubstrateRecorder`].168	pub fn new_with_recorder(id: CollectionId, recorder: SubstrateRecorder<T>) -> Option<Self> {169		<CollectionById<T>>::get(id).map(|collection| Self {170			id,171			collection,172			recorder,173		})174	}175176	/// Retrives collection data from storage and creates collection handle with default parameters.177	/// If collection not found return `None`178	pub fn new(id: CollectionId) -> Option<Self> {179		Self::new_with_gas_limit(id, u64::MAX)180	}181182	/// Same as [`CollectionHandle::new`] but if collection not found [CollectionNotFound](Error::CollectionNotFound) returned.183	pub fn try_get(id: CollectionId) -> Result<Self, DispatchError> {184		Ok(Self::new(id).ok_or(<Error<T>>::CollectionNotFound)?)185	}186187	/// Consume gas for reading.188	pub fn consume_store_reads(&self, reads: u64) -> evm_coder::execution::Result<()> {189		self.recorder190			.consume_gas(T::GasWeightMapping::weight_to_gas(Weight::from_ref_time(191				<T as frame_system::Config>::DbWeight::get()192					.read193					.saturating_mul(reads),194			)))195	}196197	/// Consume gas for writing.198	pub fn consume_store_writes(&self, writes: u64) -> evm_coder::execution::Result<()> {199		self.recorder200			.consume_gas(T::GasWeightMapping::weight_to_gas(Weight::from_ref_time(201				<T as frame_system::Config>::DbWeight::get()202					.write203					.saturating_mul(writes),204			)))205	}206207	/// Consume gas for reading and writing.208	pub fn consume_store_reads_and_writes(209		&self,210		reads: u64,211		writes: u64,212	) -> evm_coder::execution::Result<()> {213		let weight = <T as frame_system::Config>::DbWeight::get();214		let reads = weight.read.saturating_mul(reads);215		let writes = weight.read.saturating_mul(writes);216		self.recorder217			.consume_gas(T::GasWeightMapping::weight_to_gas(Weight::from_ref_time(218				reads.saturating_add(writes),219			)))220	}221222	/// Save collection to storage.223	pub fn save(&self) -> DispatchResult {224		<CollectionById<T>>::insert(self.id, &self.collection);225		Ok(())226	}227228	/// Set collection sponsor.229	///230	/// Unique collections allows sponsoring for certain actions.231	/// This method allows you to set the sponsor of the collection.232	/// In order for sponsorship to become active, it must be confirmed through [`Self::confirm_sponsorship`].233	pub fn set_sponsor(234		&mut self,235		sender: &T::CrossAccountId,236		sponsor: T::AccountId,237	) -> DispatchResult {238		self.check_is_internal()?;239		self.check_is_owner_or_admin(sender)?;240241		self.collection.sponsorship = SponsorshipState::Unconfirmed(sponsor.clone());242243		<Pallet<T>>::deposit_event(Event::<T>::CollectionSponsorSet(self.id, sponsor));244		<PalletEvm<T>>::deposit_log(245			erc::CollectionHelpersEvents::CollectionChanged {246				collection_id: eth::collection_id_to_address(self.id),247			}248			.to_log(T::ContractAddress::get()),249		);250251		self.save()252	}253254	/// Force set `sponsor`.255	///256	/// Differs from [`set_sponsor`][`Self::set_sponsor`] in that confirmation257	/// from the `sponsor` is not required.258	///259	/// # Arguments260	///261	/// * `sender`: Caller's account.262	/// * `sponsor`: ID of the account of the sponsor-to-be.263	pub fn force_set_sponsor(&mut self, sponsor: T::AccountId) -> DispatchResult {264		self.check_is_internal()?;265266		self.collection.sponsorship = SponsorshipState::Confirmed(sponsor.clone());267268		<Pallet<T>>::deposit_event(Event::<T>::CollectionSponsorSet(self.id, sponsor.clone()));269		<Pallet<T>>::deposit_event(Event::<T>::SponsorshipConfirmed(self.id, sponsor));270		<PalletEvm<T>>::deposit_log(271			erc::CollectionHelpersEvents::CollectionChanged {272				collection_id: eth::collection_id_to_address(self.id),273			}274			.to_log(T::ContractAddress::get()),275		);276277		self.save()278	}279280	/// Confirm sponsorship281	///282	/// In order for the sponsorship to become active, the user set as the sponsor must confirm their participation.283	/// Before confirming sponsorship, the user must be specified as the sponsor of the collection via [`Self::set_sponsor`].284	pub fn confirm_sponsorship(&mut self, sender: &T::AccountId) -> DispatchResult {285		self.check_is_internal()?;286		ensure!(287			self.collection.sponsorship.pending_sponsor() == Some(sender),288			Error::<T>::ConfirmSponsorshipFail289		);290291		self.collection.sponsorship = SponsorshipState::Confirmed(sender.clone());292293		<Pallet<T>>::deposit_event(Event::<T>::SponsorshipConfirmed(self.id, sender.clone()));294		<PalletEvm<T>>::deposit_log(295			erc::CollectionHelpersEvents::CollectionChanged {296				collection_id: eth::collection_id_to_address(self.id),297			}298			.to_log(T::ContractAddress::get()),299		);300301		self.save()302	}303304	/// Remove collection sponsor.305	pub fn remove_sponsor(&mut self, sender: &T::CrossAccountId) -> DispatchResult {306		self.check_is_internal()?;307		self.check_is_owner_or_admin(sender)?;308309		self.collection.sponsorship = SponsorshipState::Disabled;310311		<Pallet<T>>::deposit_event(Event::<T>::CollectionSponsorRemoved(self.id));312		<PalletEvm<T>>::deposit_log(313			erc::CollectionHelpersEvents::CollectionChanged {314				collection_id: eth::collection_id_to_address(self.id),315			}316			.to_log(T::ContractAddress::get()),317		);318		self.save()319	}320321	/// Force remove `sponsor`.322	///323	/// Differs from `remove_sponsor` in that324	/// it doesn't require consent from the `owner` of the collection.325	pub fn force_remove_sponsor(&mut self) -> DispatchResult {326		self.check_is_internal()?;327328		self.collection.sponsorship = SponsorshipState::Disabled;329330		<Pallet<T>>::deposit_event(Event::<T>::CollectionSponsorRemoved(self.id));331		<PalletEvm<T>>::deposit_log(332			erc::CollectionHelpersEvents::CollectionChanged {333				collection_id: eth::collection_id_to_address(self.id),334			}335			.to_log(T::ContractAddress::get()),336		);337		self.save()338	}339340	/// Checks that the collection was created with, and must be operated upon through **Unique API**.341	/// Now check only the `external` flag and if it's **true**, then return [`Error::CollectionIsExternal`] error.342	pub fn check_is_internal(&self) -> DispatchResult {343		if self.flags.external {344			return Err(<Error<T>>::CollectionIsExternal)?;345		}346347		Ok(())348	}349350	/// Checks that the collection was created with, and must be operated upon through an **assimilated API**.351	/// Now check only the `external` flag and if it's **false**, then return [`Error::CollectionIsInternal`] error.352	pub fn check_is_external(&self) -> DispatchResult {353		if !self.flags.external {354			return Err(<Error<T>>::CollectionIsInternal)?;355		}356357		Ok(())358	}359}360361impl<T: Config> Deref for CollectionHandle<T> {362	type Target = Collection<T::AccountId>;363364	fn deref(&self) -> &Self::Target {365		&self.collection366	}367}368369impl<T: Config> DerefMut for CollectionHandle<T> {370	fn deref_mut(&mut self) -> &mut Self::Target {371		&mut self.collection372	}373}374375impl<T: Config> CollectionHandle<T> {376	/// Checks if the `user` is the owner of the collection.377	pub fn check_is_owner(&self, user: &T::CrossAccountId) -> DispatchResult {378		ensure!(*user.as_sub() == self.owner, <Error<T>>::NoPermission);379		Ok(())380	}381382	/// Returns **true** if the `user` is the owner or administrator of the collection.383	pub fn is_owner_or_admin(&self, user: &T::CrossAccountId) -> bool {384		*user.as_sub() == self.owner || <IsAdmin<T>>::get((self.id, user))385	}386387	/// Checks if the `user` is the owner or administrator of the collection.388	pub fn check_is_owner_or_admin(&self, user: &T::CrossAccountId) -> DispatchResult {389		ensure!(self.is_owner_or_admin(user), <Error<T>>::NoPermission);390		Ok(())391	}392393	/// Return **true** if `user` was not allowed to have tokens, and he can ignore such restrictions.394	pub fn ignores_allowance(&self, user: &T::CrossAccountId) -> bool {395		self.limits.owner_can_transfer() && self.is_owner_or_admin(user)396	}397398	/// Return **true** if `user` does not have enough token parts, and he can ignore such restrictions.399	pub fn ignores_owned_amount(&self, user: &T::CrossAccountId) -> bool {400		self.limits.owner_can_transfer() && self.is_owner_or_admin(user)401	}402403	/// Checks if the user is in the allow list. If not [Error::AddressNotInAllowlist] returns.404	pub fn check_allowlist(&self, user: &T::CrossAccountId) -> DispatchResult {405		ensure!(406			<Allowlist<T>>::get((self.id, user)),407			<Error<T>>::AddressNotInAllowlist408		);409		Ok(())410	}411412	/// Changes collection owner to another account413	/// #### Store read/writes414	/// 1 writes415	pub fn change_owner(416		&mut self,417		caller: T::CrossAccountId,418		new_owner: T::CrossAccountId,419	) -> DispatchResult {420		self.check_is_internal()?;421		self.check_is_owner(&caller)?;422		self.collection.owner = new_owner.as_sub().clone();423424		<Pallet<T>>::deposit_event(Event::<T>::CollectionOwnerChanged(425			self.id,426			new_owner.as_sub().clone(),427		));428		<PalletEvm<T>>::deposit_log(429			erc::CollectionHelpersEvents::CollectionChanged {430				collection_id: eth::collection_id_to_address(self.id),431			}432			.to_log(T::ContractAddress::get()),433		);434435		self.save()436	}437}438439#[frame_support::pallet]440pub mod pallet {441	use super::*;442	use dispatch::CollectionDispatch;443	use frame_support::{Blake2_128Concat, pallet_prelude::*, storage::Key, traits::StorageVersion};444	use frame_system::pallet_prelude::*;445	use frame_support::traits::Currency;446	use up_data_structs::{TokenId, mapping::TokenAddressMapping};447	use scale_info::TypeInfo;448	use weights::WeightInfo;449450	#[pallet::config]451	pub trait Config:452		frame_system::Config + pallet_evm_coder_substrate::Config + pallet_evm::Config + TypeInfo453	{454		/// Weight information for functions of this pallet.455		type WeightInfo: WeightInfo;456457		/// Events compatible with [`frame_system::Config::Event`].458		type RuntimeEvent: IsType<<Self as frame_system::Config>::RuntimeEvent> + From<Event<Self>>;459460		/// Handler of accounts and payment.461		type Currency: Currency<Self::AccountId>;462463		/// Set price to create a collection.464		#[pallet::constant]465		type CollectionCreationPrice: Get<466			<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,467		>;468469		/// Dispatcher of operations on collections.470		type CollectionDispatch: CollectionDispatch<Self>;471472		/// Account which holds the chain's treasury.473		type TreasuryAccountId: Get<Self::AccountId>;474475		/// Address under which the CollectionHelper contract would be available.476		#[pallet::constant]477		type ContractAddress: Get<H160>;478479		/// Mapper for token addresses to Ethereum addresses.480		type EvmTokenAddressMapping: TokenAddressMapping<H160>;481482		/// Mapper for token addresses to [`CrossAccountId`].483		type CrossTokenAddressMapping: TokenAddressMapping<Self::CrossAccountId>;484	}485486	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);487488	#[pallet::pallet]489	#[pallet::storage_version(STORAGE_VERSION)]490	#[pallet::generate_store(pub(super) trait Store)]491	pub struct Pallet<T>(_);492493	#[pallet::extra_constants]494	impl<T: Config> Pallet<T> {495		/// Maximum admins per collection.496		pub fn collection_admins_limit() -> u32 {497			COLLECTION_ADMINS_LIMIT498		}499	}500501	#[pallet::event]502	#[pallet::generate_deposit(pub fn deposit_event)]503	pub enum Event<T: Config> {504		/// New collection was created505		CollectionCreated(506			/// Globally unique identifier of newly created collection.507			CollectionId,508			/// [`CollectionMode`] converted into _u8_.509			u8,510			/// Collection owner.511			T::AccountId,512		),513514		/// New collection was destroyed515		CollectionDestroyed(516			/// Globally unique identifier of collection.517			CollectionId,518		),519520		/// New item was created.521		ItemCreated(522			/// Id of the collection where item was created.523			CollectionId,524			/// Id of an item. Unique within the collection.525			TokenId,526			/// Owner of newly created item527			T::CrossAccountId,528			/// Always 1 for NFT529			u128,530		),531532		/// Collection item was burned.533		ItemDestroyed(534			/// Id of the collection where item was destroyed.535			CollectionId,536			/// Identifier of burned NFT.537			TokenId,538			/// Which user has destroyed its tokens.539			T::CrossAccountId,540			/// Amount of token pieces destroed. Always 1 for NFT.541			u128,542		),543544		/// Item was transferred545		Transfer(546			/// Id of collection to which item is belong.547			CollectionId,548			/// Id of an item.549			TokenId,550			/// Original owner of item.551			T::CrossAccountId,552			/// New owner of item.553			T::CrossAccountId,554			/// Amount of token pieces transfered. Always 1 for NFT.555			u128,556		),557558		/// Amount pieces of token owned by `sender` was approved for `spender`.559		Approved(560			/// Id of collection to which item is belong.561			CollectionId,562			/// Id of an item.563			TokenId,564			/// Original owner of item.565			T::CrossAccountId,566			/// Id for which the approval was granted.567			T::CrossAccountId,568			/// Amount of token pieces transfered. Always 1 for NFT.569			u128,570		),571572		/// A `sender` approves operations on all owned tokens for `spender`.573		ApprovedForAll(574			/// Id of collection to which item is belong.575			CollectionId,576			/// Owner of a wallet.577			T::CrossAccountId,578			/// Id for which operator status was granted or rewoked.579			T::CrossAccountId,580			/// Is operator status granted or revoked?581			bool,582		),583584		/// The colletion property has been added or edited.585		CollectionPropertySet(586			/// Id of collection to which property has been set.587			CollectionId,588			/// The property that was set.589			PropertyKey,590		),591592		/// The property has been deleted.593		CollectionPropertyDeleted(594			/// Id of collection to which property has been deleted.595			CollectionId,596			/// The property that was deleted.597			PropertyKey,598		),599600		/// The token property has been added or edited.601		TokenPropertySet(602			/// Identifier of the collection whose token has the property set.603			CollectionId,604			/// The token for which the property was set.605			TokenId,606			/// The property that was set.607			PropertyKey,608		),609610		/// The token property has been deleted.611		TokenPropertyDeleted(612			/// Identifier of the collection whose token has the property deleted.613			CollectionId,614			/// The token for which the property was deleted.615			TokenId,616			/// The property that was deleted.617			PropertyKey,618		),619620		/// The token property permission of a collection has been set.621		PropertyPermissionSet(622			/// ID of collection to which property permission has been set.623			CollectionId,624			/// The property permission that was set.625			PropertyKey,626		),627628		/// Address was added to the allow list.629		AllowListAddressAdded(630			/// ID of the affected collection.631			CollectionId,632			/// Address of the added account.633			T::CrossAccountId,634		),635636		/// Address was removed from the allow list.637		AllowListAddressRemoved(638			/// ID of the affected collection.639			CollectionId,640			/// Address of the removed account.641			T::CrossAccountId,642		),643644		/// Collection admin was added.645		CollectionAdminAdded(646			/// ID of the affected collection.647			CollectionId,648			/// Admin address.649			T::CrossAccountId,650		),651652		/// Collection admin was removed.653		CollectionAdminRemoved(654			/// ID of the affected collection.655			CollectionId,656			/// Removed admin address.657			T::CrossAccountId,658		),659660		/// Collection limits were set.661		CollectionLimitSet(662			/// ID of the affected collection.663			CollectionId,664		),665666		/// Collection owned was changed.667		CollectionOwnerChanged(668			/// ID of the affected collection.669			CollectionId,670			/// New owner address.671			T::AccountId,672		),673674		/// Collection permissions were set.675		CollectionPermissionSet(676			/// ID of the affected collection.677			CollectionId,678		),679680		/// Collection sponsor was set.681		CollectionSponsorSet(682			/// ID of the affected collection.683			CollectionId,684			/// New sponsor address.685			T::AccountId,686		),687688		/// New sponsor was confirm.689		SponsorshipConfirmed(690			/// ID of the affected collection.691			CollectionId,692			/// New sponsor address.693			T::AccountId,694		),695696		/// Collection sponsor was removed.697		CollectionSponsorRemoved(698			/// ID of the affected collection.699			CollectionId,700		),701	}702703	#[pallet::error]704	pub enum Error<T> {705		/// This collection does not exist.706		CollectionNotFound,707		/// Sender parameter and item owner must be equal.708		MustBeTokenOwner,709		/// No permission to perform action710		NoPermission,711		/// Destroying only empty collections is allowed712		CantDestroyNotEmptyCollection,713		/// Collection is not in mint mode.714		PublicMintingNotAllowed,715		/// Address is not in allow list.716		AddressNotInAllowlist,717718		/// Collection name can not be longer than 63 char.719		CollectionNameLimitExceeded,720		/// Collection description can not be longer than 255 char.721		CollectionDescriptionLimitExceeded,722		/// Token prefix can not be longer than 15 char.723		CollectionTokenPrefixLimitExceeded,724		/// Total collections bound exceeded.725		TotalCollectionsLimitExceeded,726		/// Exceeded max admin count727		CollectionAdminCountExceeded,728		/// Collection limit bounds per collection exceeded729		CollectionLimitBoundsExceeded,730		/// Tried to enable permissions which are only permitted to be disabled731		OwnerPermissionsCantBeReverted,732		/// Collection settings not allowing items transferring733		TransferNotAllowed,734		/// Account token limit exceeded per collection735		AccountTokenLimitExceeded,736		/// Collection token limit exceeded737		CollectionTokenLimitExceeded,738		/// Metadata flag frozen739		MetadataFlagFrozen,740741		/// Item does not exist742		TokenNotFound,743		/// Item is balance not enough744		TokenValueTooLow,745		/// Requested value is more than the approved746		ApprovedValueTooLow,747		/// Tried to approve more than owned748		CantApproveMoreThanOwned,749750		/// Can't transfer tokens to ethereum zero address751		AddressIsZero,752753		/// The operation is not supported754		UnsupportedOperation,755756		/// Insufficient funds to perform an action757		NotSufficientFounds,758759		/// User does not satisfy the nesting rule760		UserIsNotAllowedToNest,761		/// Only tokens from specific collections may nest tokens under this one762		SourceCollectionIsNotAllowedToNest,763764		/// Tried to store more data than allowed in collection field765		CollectionFieldSizeExceeded,766767		/// Tried to store more property data than allowed768		NoSpaceForProperty,769770		/// Tried to store more property keys than allowed771		PropertyLimitReached,772773		/// Property key is too long774		PropertyKeyIsTooLong,775776		/// Only ASCII letters, digits, and symbols `_`, `-`, and `.` are allowed777		InvalidCharacterInPropertyKey,778779		/// Empty property keys are forbidden780		EmptyPropertyKey,781782		/// Tried to access an external collection with an internal API783		CollectionIsExternal,784785		/// Tried to access an internal collection with an external API786		CollectionIsInternal,787788		/// This address is not set as sponsor, use setCollectionSponsor first.789		ConfirmSponsorshipFail,790791		/// The user is not an administrator.792		UserIsNotCollectionAdmin,793	}794795	/// Storage of the count of created collections. Essentially contains the last collection ID.796	#[pallet::storage]797	pub type CreatedCollectionCount<T> = StorageValue<Value = CollectionId, QueryKind = ValueQuery>;798799	/// Storage of the count of deleted collections.800	#[pallet::storage]801	pub type DestroyedCollectionCount<T> =802		StorageValue<Value = CollectionId, QueryKind = ValueQuery>;803804	/// Storage of collection info.805	#[pallet::storage]806	pub type CollectionById<T> = StorageMap<807		Hasher = Blake2_128Concat,808		Key = CollectionId,809		Value = Collection<<T as frame_system::Config>::AccountId>,810		QueryKind = OptionQuery,811	>;812813	/// Storage of collection properties.814	#[pallet::storage]815	#[pallet::getter(fn collection_properties)]816	pub type CollectionProperties<T> = StorageMap<817		Hasher = Blake2_128Concat,818		Key = CollectionId,819		Value = Properties,820		QueryKind = ValueQuery,821		OnEmpty = up_data_structs::CollectionProperties,822	>;823824	/// Storage of token property permissions of a collection.825	#[pallet::storage]826	#[pallet::getter(fn property_permissions)]827	pub type CollectionPropertyPermissions<T> = StorageMap<828		Hasher = Blake2_128Concat,829		Key = CollectionId,830		Value = PropertiesPermissionMap,831		QueryKind = ValueQuery,832	>;833834	/// Storage of the amount of collection admins.835	#[pallet::storage]836	pub type AdminAmount<T> = StorageMap<837		Hasher = Blake2_128Concat,838		Key = CollectionId,839		Value = u32,840		QueryKind = ValueQuery,841	>;842843	/// List of collection admins.844	#[pallet::storage]845	pub type IsAdmin<T: Config> = StorageNMap<846		Key = (847			Key<Blake2_128Concat, CollectionId>,848			Key<Blake2_128Concat, T::CrossAccountId>,849		),850		Value = bool,851		QueryKind = ValueQuery,852	>;853854	/// Allowlisted collection users.855	#[pallet::storage]856	pub type Allowlist<T: Config> = StorageNMap<857		Key = (858			Key<Blake2_128Concat, CollectionId>,859			Key<Blake2_128Concat, T::CrossAccountId>,860		),861		Value = bool,862		QueryKind = ValueQuery,863	>;864865	/// Not used by code, exists only to provide some types to metadata.866	#[pallet::storage]867	pub type DummyStorageValue<T: Config> = StorageValue<868		Value = (869			CollectionStats,870			CollectionId,871			TokenId,872			TokenChild,873			PhantomType<(874				TokenData<T::CrossAccountId>,875				RpcCollection<T::AccountId>,876				// RMRK877				RmrkCollectionInfo<T::AccountId>,878				RmrkInstanceInfo<T::AccountId>,879				RmrkResourceInfo,880				RmrkPropertyInfo,881				RmrkBaseInfo<T::AccountId>,882				RmrkPartType,883				RmrkBoundedTheme,884				RmrkNftChild,885				// PoV Estimate Info886				PovInfo,887			)>,888		),889		QueryKind = OptionQuery,890	>;891892	#[pallet::hooks]893	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {894		fn on_runtime_upgrade() -> Weight {895			StorageVersion::new(1).put::<Pallet<T>>();896897			Weight::zero()898		}899	}900}901902impl<T: Config> Pallet<T> {903	/// Enshure that receiver address is correct.904	///905	/// Ethereum receiver 0x0000000000000000000000000000000000000000 is reserved, and shouldn't own tokens.906	pub fn ensure_correct_receiver(receiver: &T::CrossAccountId) -> DispatchResult {907		ensure!(908			&T::CrossAccountId::from_eth(H160([0; 20])) != receiver,909			<Error<T>>::AddressIsZero910		);911		Ok(())912	}913914	/// Get a vector of collection admins.915	pub fn adminlist(collection: CollectionId) -> Vec<T::CrossAccountId> {916		<IsAdmin<T>>::iter_prefix((collection,))917			.map(|(a, _)| a)918			.collect()919	}920921	/// Get a vector of users allowed to mint tokens.922	pub fn allowlist(collection: CollectionId) -> Vec<T::CrossAccountId> {923		<Allowlist<T>>::iter_prefix((collection,))924			.map(|(a, _)| a)925			.collect()926	}927928	/// Is `user` allowed to mint token in `collection`.929	pub fn allowed(collection: CollectionId, user: T::CrossAccountId) -> bool {930		<Allowlist<T>>::get((collection, user))931	}932933	/// Get statistics of collections.934	pub fn collection_stats() -> CollectionStats {935		let created = <CreatedCollectionCount<T>>::get();936		let destroyed = <DestroyedCollectionCount<T>>::get();937		CollectionStats {938			created: created.0,939			destroyed: destroyed.0,940			alive: created.0 - destroyed.0,941		}942	}943944	/// Get the effective limits for the collection.945	pub fn effective_collection_limits(collection: CollectionId) -> Option<CollectionLimits> {946		let collection = <CollectionById<T>>::get(collection)?;947		let limits = collection.limits;948		let effective_limits = CollectionLimits {949			account_token_ownership_limit: Some(limits.account_token_ownership_limit()),950			sponsored_data_size: Some(limits.sponsored_data_size()),951			sponsored_data_rate_limit: Some(952				limits953					.sponsored_data_rate_limit954					.unwrap_or(SponsoringRateLimit::SponsoringDisabled),955			),956			token_limit: Some(limits.token_limit()),957			sponsor_transfer_timeout: Some(limits.sponsor_transfer_timeout(958				match collection.mode {959					CollectionMode::NFT => NFT_SPONSOR_TRANSFER_TIMEOUT,960					CollectionMode::Fungible(_) => FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,961					CollectionMode::ReFungible => REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,962				},963			)),964			sponsor_approve_timeout: Some(limits.sponsor_approve_timeout()),965			owner_can_transfer: Some(limits.owner_can_transfer()),966			owner_can_destroy: Some(limits.owner_can_destroy()),967			transfers_enabled: Some(limits.transfers_enabled()),968		};969970		Some(effective_limits)971	}972973	/// Returns information about the `collection` adapted for rpc.974	pub fn rpc_collection(collection: CollectionId) -> Option<RpcCollection<T::AccountId>> {975		let Collection {976			name,977			description,978			owner,979			mode,980			token_prefix,981			sponsorship,982			limits,983			permissions,984			flags,985		} = <CollectionById<T>>::get(collection)?;986987		let token_property_permissions = <CollectionPropertyPermissions<T>>::get(collection)988			.into_iter()989			.map(|(key, permission)| PropertyKeyPermission { key, permission })990			.collect();991992		let properties = <CollectionProperties<T>>::get(collection)993			.into_iter()994			.map(|(key, value)| Property { key, value })995			.collect();996997		let permissions = CollectionPermissions {998			access: Some(permissions.access()),999			mint_mode: Some(permissions.mint_mode()),1000			nesting: Some(permissions.nesting().clone()),1001		};10021003		Some(RpcCollection {1004			name: name.into_inner(),1005			description: description.into_inner(),1006			owner,1007			mode,1008			token_prefix: token_prefix.into_inner(),1009			sponsorship,1010			limits,1011			permissions,1012			token_property_permissions,1013			properties,1014			read_only: flags.external,10151016			flags: RpcCollectionFlags {1017				foreign: flags.foreign,1018				erc721metadata: flags.erc721metadata,1019			},1020		})1021	}1022}10231024macro_rules! limit_default {1025	($old:ident, $new:ident, $($field:ident $(($arg:expr))? => $check:expr),* $(,)?) => {{1026		$(1027			if let Some($new) = $new.$field {1028				let $old = $old.$field($($arg)?);1029				let _ = $new;1030				let _ = $old;1031				$check1032			} else {1033				$new.$field = $old.$field1034			}1035		)*1036	}};1037}1038macro_rules! limit_default_clone {1039	($old:ident, $new:ident, $($field:ident $(($arg:expr))? => $check:expr),* $(,)?) => {{1040		$(1041			if let Some($new) = $new.$field.clone() {1042				let $old = $old.$field($($arg)?);1043				let _ = $new;1044				let _ = $old;1045				$check1046			} else {1047				$new.$field = $old.$field.clone()1048			}1049		)*1050	}};1051}10521053impl<T: Config> Pallet<T> {1054	/// Create new collection.1055	///1056	/// * `owner` - The owner of the collection.1057	/// * `data` - Description of the created collection.1058	/// * `flags` - Extra flags to store.1059	pub fn init_collection(1060		owner: T::CrossAccountId,1061		payer: T::CrossAccountId,1062		data: CreateCollectionData<T::AccountId>,1063		flags: CollectionFlags,1064	) -> Result<CollectionId, DispatchError> {1065		{1066			ensure!(1067				data.token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH as usize,1068				Error::<T>::CollectionTokenPrefixLimitExceeded1069			);1070		}10711072		let created_count = <CreatedCollectionCount<T>>::get()1073			.01074			.checked_add(1)1075			.ok_or(ArithmeticError::Overflow)?;1076		let destroyed_count = <DestroyedCollectionCount<T>>::get().0;1077		let id = CollectionId(created_count);10781079		// bound Total number of collections1080		ensure!(1081			created_count - destroyed_count <= COLLECTION_NUMBER_LIMIT,1082			<Error<T>>::TotalCollectionsLimitExceeded1083		);10841085		// =========10861087		let collection = Collection {1088			owner: owner.as_sub().clone(),1089			name: data.name,1090			mode: data.mode.clone(),1091			description: data.description,1092			token_prefix: data.token_prefix,1093			sponsorship: data1094				.pending_sponsor1095				.map(SponsorshipState::Unconfirmed)1096				.unwrap_or_default(),1097			limits: data1098				.limits1099				.map(|limits| Self::clamp_limits(data.mode.clone(), &Default::default(), limits))1100				.unwrap_or_else(|| Ok(CollectionLimits::default()))?,1101			permissions: data1102				.permissions1103				.map(|permissions| {1104					Self::clamp_permissions(data.mode.clone(), &Default::default(), permissions)1105				})1106				.unwrap_or_else(|| Ok(CollectionPermissions::default()))?,1107			flags,1108		};11091110		let mut collection_properties = up_data_structs::CollectionProperties::get();1111		collection_properties1112			.try_set_from_iter(data.properties.into_iter())1113			.map_err(<Error<T>>::from)?;11141115		CollectionProperties::<T>::insert(id, collection_properties);11161117		let mut token_props_permissions = PropertiesPermissionMap::new();1118		token_props_permissions1119			.try_set_from_iter(data.token_property_permissions.into_iter())1120			.map_err(<Error<T>>::from)?;11211122		CollectionPropertyPermissions::<T>::insert(id, token_props_permissions);11231124		// Take a (non-refundable) deposit of collection creation1125		{1126			let mut imbalance =1127				<<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();1128			imbalance.subsume(1129				<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(1130					&T::TreasuryAccountId::get(),1131					T::CollectionCreationPrice::get(),1132				),1133			);1134			<T as Config>::Currency::settle(1135				payer.as_sub(),1136				imbalance,1137				WithdrawReasons::TRANSFER,1138				ExistenceRequirement::KeepAlive,1139			)1140			.map_err(|_| Error::<T>::NotSufficientFounds)?;1141		}11421143		<CreatedCollectionCount<T>>::put(created_count);1144		<Pallet<T>>::deposit_event(Event::CollectionCreated(1145			id,1146			data.mode.id(),1147			owner.as_sub().clone(),1148		));1149		<PalletEvm<T>>::deposit_log(1150			erc::CollectionHelpersEvents::CollectionCreated {1151				owner: *owner.as_eth(),1152				collection_id: eth::collection_id_to_address(id),1153			}1154			.to_log(T::ContractAddress::get()),1155		);1156		<CollectionById<T>>::insert(id, collection);1157		Ok(id)1158	}11591160	/// Destroy collection.1161	///1162	/// * `collection` - Collection handler.1163	/// * `sender` - The owner or administrator of the collection.1164	pub fn destroy_collection(1165		collection: CollectionHandle<T>,1166		sender: &T::CrossAccountId,1167	) -> DispatchResult {1168		ensure!(1169			collection.limits.owner_can_destroy(),1170			<Error<T>>::NoPermission,1171		);1172		collection.check_is_owner(sender)?;11731174		let destroyed_collections = <DestroyedCollectionCount<T>>::get()1175			.01176			.checked_add(1)1177			.ok_or(ArithmeticError::Overflow)?;11781179		// =========11801181		<DestroyedCollectionCount<T>>::put(destroyed_collections);1182		<CollectionById<T>>::remove(collection.id);1183		<AdminAmount<T>>::remove(collection.id);1184		let _ = <IsAdmin<T>>::clear_prefix((collection.id,), u32::MAX, None);1185		let _ = <Allowlist<T>>::clear_prefix((collection.id,), u32::MAX, None);1186		<CollectionProperties<T>>::remove(collection.id);11871188		<Pallet<T>>::deposit_event(Event::CollectionDestroyed(collection.id));11891190		<PalletEvm<T>>::deposit_log(1191			erc::CollectionHelpersEvents::CollectionDestroyed {1192				collection_id: eth::collection_id_to_address(collection.id),1193			}1194			.to_log(T::ContractAddress::get()),1195		);1196		Ok(())1197	}11981199	/// Set collection property.1200	///1201	/// * `collection` - Collection handler.1202	/// * `sender` - The owner or administrator of the collection.1203	/// * `property` - The property to set.1204	pub fn set_collection_property(1205		collection: &CollectionHandle<T>,1206		sender: &T::CrossAccountId,1207		property: Property,1208	) -> DispatchResult {1209		collection.check_is_owner_or_admin(sender)?;12101211		CollectionProperties::<T>::try_mutate(collection.id, |properties| {1212			let property = property.clone();1213			properties.try_set(property.key, property.value)1214		})1215		.map_err(<Error<T>>::from)?;12161217		Self::deposit_event(Event::CollectionPropertySet(collection.id, property.key));1218		<PalletEvm<T>>::deposit_log(1219			erc::CollectionHelpersEvents::CollectionChanged {1220				collection_id: eth::collection_id_to_address(collection.id),1221			}1222			.to_log(T::ContractAddress::get()),1223		);12241225		Ok(())1226	}12271228	/// Set a scoped collection property, where the scope is a special prefix1229	/// prohibiting a user access to change the property directly.1230	///1231	/// * `collection_id` - ID of the collection for which the property is being set.1232	/// * `scope` - Property scope.1233	/// * `property` - The property to set.1234	pub fn set_scoped_collection_property(1235		collection_id: CollectionId,1236		scope: PropertyScope,1237		property: Property,1238	) -> DispatchResult {1239		CollectionProperties::<T>::try_mutate(collection_id, |properties| {1240			properties.try_scoped_set(scope, property.key, property.value)1241		})1242		.map_err(<Error<T>>::from)?;12431244		Ok(())1245	}12461247	/// Set scoped collection properties, where the scope is a special prefix1248	/// prohibiting a user access to change the properties directly.1249	///1250	/// * `collection_id` - ID of the collection for which the properties is being set.1251	/// * `scope` - Property scope.1252	/// * `properties` - The properties to set.1253	pub fn set_scoped_collection_properties(1254		collection_id: CollectionId,1255		scope: PropertyScope,1256		properties: impl Iterator<Item = Property>,1257	) -> DispatchResult {1258		CollectionProperties::<T>::try_mutate(collection_id, |stored_properties| {1259			stored_properties.try_scoped_set_from_iter(scope, properties)1260		})1261		.map_err(<Error<T>>::from)?;12621263		Ok(())1264	}12651266	/// Set collection properties.1267	///1268	/// * `collection` - Collection handler.1269	/// * `sender` - The owner or administrator of the collection.1270	/// * `properties` - The properties to set.1271	#[transactional]1272	pub fn set_collection_properties(1273		collection: &CollectionHandle<T>,1274		sender: &T::CrossAccountId,1275		properties: Vec<Property>,1276	) -> DispatchResult {1277		for property in properties {1278			Self::set_collection_property(collection, sender, property)?;1279		}12801281		Ok(())1282	}12831284	/// Delete collection property.1285	///1286	/// * `collection` - Collection handler.1287	/// * `sender` - The owner or administrator of the collection.1288	/// * `property` - The property to delete.1289	pub fn delete_collection_property(1290		collection: &CollectionHandle<T>,1291		sender: &T::CrossAccountId,1292		property_key: PropertyKey,1293	) -> DispatchResult {1294		collection.check_is_owner_or_admin(sender)?;12951296		CollectionProperties::<T>::try_mutate(collection.id, |properties| {1297			properties.remove(&property_key)1298		})1299		.map_err(<Error<T>>::from)?;13001301		Self::deposit_event(Event::CollectionPropertyDeleted(1302			collection.id,1303			property_key,1304		));1305		<PalletEvm<T>>::deposit_log(1306			erc::CollectionHelpersEvents::CollectionChanged {1307				collection_id: eth::collection_id_to_address(collection.id),1308			}1309			.to_log(T::ContractAddress::get()),1310		);13111312		Ok(())1313	}13141315	/// Delete collection properties.1316	///1317	/// * `collection` - Collection handler.1318	/// * `sender` - The owner or administrator of the collection.1319	/// * `properties` - The properties to delete.1320	#[transactional]1321	pub fn delete_collection_properties(1322		collection: &CollectionHandle<T>,1323		sender: &T::CrossAccountId,1324		property_keys: Vec<PropertyKey>,1325	) -> DispatchResult {1326		for key in property_keys {1327			Self::delete_collection_property(collection, sender, key)?;1328		}13291330		Ok(())1331	}13321333	/// Set collection propetry permission without any checks.1334	///1335	/// Used for migrations.1336	///1337	/// * `collection` - Collection handler.1338	/// * `property_permissions` - Property permissions.1339	pub fn set_property_permission_unchecked(1340		collection: CollectionId,1341		property_permission: PropertyKeyPermission,1342	) -> DispatchResult {1343		<CollectionPropertyPermissions<T>>::try_mutate(collection, |permissions| {1344			permissions.try_set(property_permission.key, property_permission.permission)1345		})1346		.map_err(<Error<T>>::from)?;1347		Ok(())1348	}13491350	/// Set collection property permission.1351	///1352	/// * `collection` - Collection handler.1353	/// * `sender` - The owner or administrator of the collection.1354	/// * `property_permission` - Property permission.1355	pub fn set_property_permission(1356		collection: &CollectionHandle<T>,1357		sender: &T::CrossAccountId,1358		property_permission: PropertyKeyPermission,1359	) -> DispatchResult {1360		Self::set_scoped_property_permission(1361			collection,1362			sender,1363			PropertyScope::None,1364			property_permission,1365		)1366	}13671368	/// Set collection property permission with scope.1369	///1370	/// * `collection` - Collection handler.1371	/// * `sender` - The owner or administrator of the collection.1372	/// * `scope` - Property scope.1373	/// * `property_permission` - Property permission.1374	pub fn set_scoped_property_permission(1375		collection: &CollectionHandle<T>,1376		sender: &T::CrossAccountId,1377		scope: PropertyScope,1378		property_permission: PropertyKeyPermission,1379	) -> DispatchResult {1380		collection.check_is_owner_or_admin(sender)?;13811382		let all_permissions = CollectionPropertyPermissions::<T>::get(collection.id);1383		let current_permission = all_permissions.get(&property_permission.key);1384		if matches![1385			current_permission,1386			Some(PropertyPermission { mutable: false, .. })1387		] {1388			return Err(<Error<T>>::NoPermission.into());1389		}13901391		CollectionPropertyPermissions::<T>::try_mutate(collection.id, |permissions| {1392			let property_permission = property_permission.clone();1393			permissions.try_scoped_set(1394				scope,1395				property_permission.key,1396				property_permission.permission,1397			)1398		})1399		.map_err(<Error<T>>::from)?;14001401		Self::deposit_event(Event::PropertyPermissionSet(1402			collection.id,1403			property_permission.key,1404		));1405		<PalletEvm<T>>::deposit_log(1406			erc::CollectionHelpersEvents::CollectionChanged {1407				collection_id: eth::collection_id_to_address(collection.id),1408			}1409			.to_log(T::ContractAddress::get()),1410		);14111412		Ok(())1413	}14141415	/// Set token property permission.1416	///1417	/// * `collection` - Collection handler.1418	/// * `sender` - The owner or administrator of the collection.1419	/// * `property_permissions` - Property permissions.1420	#[transactional]1421	pub fn set_token_property_permissions(1422		collection: &CollectionHandle<T>,1423		sender: &T::CrossAccountId,1424		property_permissions: Vec<PropertyKeyPermission>,1425	) -> DispatchResult {1426		Self::set_scoped_token_property_permissions(1427			collection,1428			sender,1429			PropertyScope::None,1430			property_permissions,1431		)1432	}14331434	/// Set token property permission with scope.1435	///1436	/// * `collection` - Collection handler.1437	/// * `sender` - The owner or administrator of the collection.1438	/// * `scope` - Property scope.1439	/// * `property_permissions` - Property permissions.1440	#[transactional]1441	pub fn set_scoped_token_property_permissions(1442		collection: &CollectionHandle<T>,1443		sender: &T::CrossAccountId,1444		scope: PropertyScope,1445		property_permissions: Vec<PropertyKeyPermission>,1446	) -> DispatchResult {1447		for prop_pemission in property_permissions {1448			Self::set_scoped_property_permission(collection, sender, scope, prop_pemission)?;1449		}14501451		Ok(())1452	}14531454	/// Get collection property.1455	pub fn get_collection_property(1456		collection_id: CollectionId,1457		key: &PropertyKey,1458	) -> Option<PropertyValue> {1459		Self::collection_properties(collection_id).get(key).cloned()1460	}14611462	/// Convert byte vector to property key vector.1463	pub fn bytes_keys_to_property_keys(1464		keys: Vec<Vec<u8>>,1465	) -> Result<Vec<PropertyKey>, DispatchError> {1466		keys.into_iter()1467			.map(|key| -> Result<PropertyKey, DispatchError> {1468				key.try_into()1469					.map_err(|_| <Error<T>>::PropertyKeyIsTooLong.into())1470			})1471			.collect::<Result<Vec<PropertyKey>, DispatchError>>()1472	}14731474	/// Get properties according to given keys.1475	pub fn filter_collection_properties(1476		collection_id: CollectionId,1477		keys: Option<Vec<PropertyKey>>,1478	) -> Result<Vec<Property>, DispatchError> {1479		let properties = Self::collection_properties(collection_id);14801481		let properties = keys1482			.map(|keys| {1483				keys.into_iter()1484					.filter_map(|key| {1485						properties.get(&key).map(|value| Property {1486							key,1487							value: value.clone(),1488						})1489					})1490					.collect()1491			})1492			.unwrap_or_else(|| {1493				properties1494					.into_iter()1495					.map(|(key, value)| Property { key, value })1496					.collect()1497			});14981499		Ok(properties)1500	}15011502	/// Get property permissions according to given keys.1503	pub fn filter_property_permissions(1504		collection_id: CollectionId,1505		keys: Option<Vec<PropertyKey>>,1506	) -> Result<Vec<PropertyKeyPermission>, DispatchError> {1507		let permissions = Self::property_permissions(collection_id);15081509		let key_permissions = keys1510			.map(|keys| {1511				keys.into_iter()1512					.filter_map(|key| {1513						permissions1514							.get(&key)1515							.map(|permission| PropertyKeyPermission {1516								key,1517								permission: permission.clone(),1518							})1519					})1520					.collect()1521			})1522			.unwrap_or_else(|| {1523				permissions1524					.into_iter()1525					.map(|(key, permission)| PropertyKeyPermission { key, permission })1526					.collect()1527			});15281529		Ok(key_permissions)1530	}15311532	/// Toggle `user` participation in the `collection`'s allow list.1533	/// #### Store read/writes1534	/// 1 writes1535	pub fn toggle_allowlist(1536		collection: &CollectionHandle<T>,1537		sender: &T::CrossAccountId,1538		user: &T::CrossAccountId,1539		allowed: bool,1540	) -> DispatchResult {1541		collection.check_is_owner_or_admin(sender)?;15421543		// =========15441545		if allowed {1546			<Allowlist<T>>::insert((collection.id, user), true);1547			Self::deposit_event(Event::<T>::AllowListAddressAdded(1548				collection.id,1549				user.clone(),1550			));1551		} else {1552			<Allowlist<T>>::remove((collection.id, user));1553			Self::deposit_event(Event::<T>::AllowListAddressRemoved(1554				collection.id,1555				user.clone(),1556			));1557		}15581559		<PalletEvm<T>>::deposit_log(1560			erc::CollectionHelpersEvents::CollectionChanged {1561				collection_id: eth::collection_id_to_address(collection.id),1562			}1563			.to_log(T::ContractAddress::get()),1564		);15651566		Ok(())1567	}15681569	/// Toggle `user` participation in the `collection`'s admin list.1570	/// #### Store read/writes1571	/// 2 reads, 2 writes1572	pub fn toggle_admin(1573		collection: &CollectionHandle<T>,1574		sender: &T::CrossAccountId,1575		user: &T::CrossAccountId,1576		admin: bool,1577	) -> DispatchResult {1578		collection.check_is_internal()?;1579		collection.check_is_owner(sender)?;15801581		let is_admin = <IsAdmin<T>>::get((collection.id, user));1582		if is_admin == admin {1583			if admin {1584				return Ok(());1585			} else {1586				return Err(Error::<T>::UserIsNotCollectionAdmin.into());1587			}1588		}1589		let amount = <AdminAmount<T>>::get(collection.id);15901591		// =========15921593		if admin {1594			let amount = amount1595				.checked_add(1)1596				.ok_or(<Error<T>>::CollectionAdminCountExceeded)?;1597			ensure!(1598				amount <= Self::collection_admins_limit(),1599				<Error<T>>::CollectionAdminCountExceeded,1600			);16011602			<AdminAmount<T>>::insert(collection.id, amount);1603			<IsAdmin<T>>::insert((collection.id, user), true);16041605			Self::deposit_event(Event::<T>::CollectionAdminAdded(1606				collection.id,1607				user.clone(),1608			));1609		} else {1610			<AdminAmount<T>>::insert(collection.id, amount.saturating_sub(1));1611			<IsAdmin<T>>::remove((collection.id, user));16121613			Self::deposit_event(Event::<T>::CollectionAdminRemoved(1614				collection.id,1615				user.clone(),1616			));1617		}16181619		<PalletEvm<T>>::deposit_log(1620			erc::CollectionHelpersEvents::CollectionChanged {1621				collection_id: eth::collection_id_to_address(collection.id),1622			}1623			.to_log(T::ContractAddress::get()),1624		);16251626		Ok(())1627	}16281629	/// Update collection limits.1630	pub fn update_limits(1631		user: &T::CrossAccountId,1632		collection: &mut CollectionHandle<T>,1633		new_limit: CollectionLimits,1634	) -> DispatchResult {1635		collection.check_is_internal()?;1636		collection.check_is_owner_or_admin(user)?;16371638		collection.limits =1639			Self::clamp_limits(collection.mode.clone(), &collection.limits, new_limit)?;16401641		Self::deposit_event(Event::<T>::CollectionLimitSet(collection.id));1642		<PalletEvm<T>>::deposit_log(1643			erc::CollectionHelpersEvents::CollectionChanged {1644				collection_id: eth::collection_id_to_address(collection.id),1645			}1646			.to_log(T::ContractAddress::get()),1647		);16481649		collection.save()1650	}16511652	/// Merge set fields from `new_limit` to `old_limit`.1653	fn clamp_limits(1654		mode: CollectionMode,1655		old_limit: &CollectionLimits,1656		mut new_limit: CollectionLimits,1657	) -> Result<CollectionLimits, DispatchError> {1658		let limits = old_limit;1659		limit_default!(old_limit, new_limit,1660			account_token_ownership_limit => ensure!(1661				new_limit <= MAX_TOKEN_OWNERSHIP,1662				<Error<T>>::CollectionLimitBoundsExceeded,1663			),1664			sponsored_data_size => ensure!(1665				new_limit <= CUSTOM_DATA_LIMIT,1666				<Error<T>>::CollectionLimitBoundsExceeded,1667			),16681669			sponsored_data_rate_limit => {},1670			token_limit => ensure!(1671				old_limit >= new_limit && new_limit > 0,1672				<Error<T>>::CollectionTokenLimitExceeded1673			),16741675			sponsor_transfer_timeout(match mode {1676				CollectionMode::NFT => NFT_SPONSOR_TRANSFER_TIMEOUT,1677				CollectionMode::Fungible(_) => FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,1678				CollectionMode::ReFungible => REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,1679			}) => ensure!(1680				new_limit <= MAX_SPONSOR_TIMEOUT,1681				<Error<T>>::CollectionLimitBoundsExceeded,1682			),1683			sponsor_approve_timeout => {},1684			owner_can_transfer => ensure!(1685				!limits.owner_can_transfer_instaled() ||1686				old_limit || !new_limit,1687				<Error<T>>::OwnerPermissionsCantBeReverted,1688			),1689			owner_can_destroy => ensure!(1690				old_limit || !new_limit,1691				<Error<T>>::OwnerPermissionsCantBeReverted,1692			),1693			transfers_enabled => {},1694		);1695		Ok(new_limit)1696	}16971698	/// Update collection permissions.1699	pub fn update_permissions(1700		user: &T::CrossAccountId,1701		collection: &mut CollectionHandle<T>,1702		new_permission: CollectionPermissions,1703	) -> DispatchResult {1704		collection.check_is_internal()?;1705		collection.check_is_owner_or_admin(user)?;1706		collection.permissions = Self::clamp_permissions(1707			collection.mode.clone(),1708			&collection.permissions,1709			new_permission,1710		)?;17111712		Self::deposit_event(Event::<T>::CollectionPermissionSet(collection.id));1713		<PalletEvm<T>>::deposit_log(1714			erc::CollectionHelpersEvents::CollectionChanged {1715				collection_id: eth::collection_id_to_address(collection.id),1716			}1717			.to_log(T::ContractAddress::get()),1718		);17191720		collection.save()1721	}17221723	/// Merge set fields from `new_permission` to `old_permission`.1724	fn clamp_permissions(1725		_mode: CollectionMode,1726		old_permission: &CollectionPermissions,1727		mut new_permission: CollectionPermissions,1728	) -> Result<CollectionPermissions, DispatchError> {1729		limit_default_clone!(old_permission, new_permission,1730			access => {},1731			mint_mode => {},1732			nesting => { /* todo check for permissive, if only it gets out of benchmarks */ },1733		);1734		Ok(new_permission)1735	}17361737	/// Repair possibly broken properties of a collection.1738	pub fn repair_collection(collection_id: CollectionId) -> DispatchResult {1739		CollectionProperties::<T>::mutate(collection_id, |properties| {1740			properties.recompute_consumed_space();1741		});17421743		Ok(())1744	}1745}17461747/// Indicates unsupported methods by returning [Error::UnsupportedOperation].1748#[macro_export]1749macro_rules! unsupported {1750	($runtime:path) => {1751		Err($crate::Error::<$runtime>::UnsupportedOperation.into())1752	};1753}17541755/// Return weights for various worst-case operations.1756pub trait CommonWeightInfo<CrossAccountId> {1757	/// Weight of item creation.1758	fn create_item() -> Weight;17591760	/// Weight of items creation.1761	fn create_multiple_items(amount: &[CreateItemData]) -> Weight;17621763	/// Weight of items creation.1764	fn create_multiple_items_ex(cost: &CreateItemExData<CrossAccountId>) -> Weight;17651766	/// The weight of the burning item.1767	fn burn_item() -> Weight;17681769	/// Property setting weight.1770	///1771	/// * `amount`- The number of properties to set.1772	fn set_collection_properties(amount: u32) -> Weight;17731774	/// Collection property deletion weight.1775	///1776	/// * `amount`- The number of properties to set.1777	fn delete_collection_properties(amount: u32) -> Weight;17781779	/// Token property setting weight.1780	///1781	/// * `amount`- The number of properties to set.1782	fn set_token_properties(amount: u32) -> Weight;17831784	/// Token property deletion weight.1785	///1786	/// * `amount`- The number of properties to delete.1787	fn delete_token_properties(amount: u32) -> Weight;17881789	/// Token property permissions set weight.1790	///1791	/// * `amount`- The number of property permissions to set.1792	fn set_token_property_permissions(amount: u32) -> Weight;17931794	/// Transfer price of the token or its parts.1795	fn transfer() -> Weight;17961797	/// The price of setting the permission of the operation from another user.1798	fn approve() -> Weight;17991800	/// Transfer price from another user.1801	fn transfer_from() -> Weight;18021803	/// The price of burning a token from another user.1804	fn burn_from() -> Weight;18051806	/// Differs from burn_item in case of Fungible and Refungible, as it should burn1807	/// whole users's balance.1808	///1809	/// This method shouldn't be used directly, as it doesn't count breadth price, use [burn_recursively](CommonWeightInfo::burn_recursively) instead1810	fn burn_recursively_self_raw() -> Weight;18111812	/// Cost of iterating over `amount` children while burning, without counting child burning itself.1813	///1814	/// This method shouldn't be used directly, as it doesn't count depth price, use [burn_recursively](CommonWeightInfo::burn_recursively) instead1815	fn burn_recursively_breadth_raw(amount: u32) -> Weight;18161817	/// The price of recursive burning a token.1818	///1819	/// `max_selfs` - The maximum burning weight of the token itself.1820	/// `max_breadth` - The maximum number of nested tokens to burn.1821	fn burn_recursively(max_selfs: u32, max_breadth: u32) -> Weight {1822		Self::burn_recursively_self_raw()1823			.saturating_mul(max_selfs.max(1) as u64)1824			.saturating_add(Self::burn_recursively_breadth_raw(max_breadth))1825	}18261827	/// The price of retrieving token owner1828	fn token_owner() -> Weight;18291830	/// The price of setting approval for all1831	fn set_allowance_for_all() -> Weight;18321833	/// The price of repairing an item.1834	fn force_repair_item() -> Weight;1835}18361837/// Weight info extension trait for refungible pallet.1838pub trait RefungibleExtensionsWeightInfo {1839	/// Weight of token repartition.1840	fn repartition() -> Weight;1841}18421843/// Common collection operations.1844///1845/// It wraps methods in Fungible, Nonfungible and Refungible pallets1846/// and adds weight info.1847pub trait CommonCollectionOperations<T: Config> {1848	/// Create token.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_item(1855		&self,1856		sender: T::CrossAccountId,1857		to: T::CrossAccountId,1858		data: 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(1869		&self,1870		sender: T::CrossAccountId,1871		to: T::CrossAccountId,1872		data: Vec<CreateItemData>,1873		nesting_budget: &dyn Budget,1874	) -> DispatchResultWithPostInfo;18751876	/// Create multiple tokens.1877	///1878	/// * `sender` - The user who mint the token and pays for the transaction.1879	/// * `to` - The user who will own the token.1880	/// * `data` - Token data.1881	/// * `nesting_budget` - A budget that can be spent on nesting tokens.1882	fn create_multiple_items_ex(1883		&self,1884		sender: T::CrossAccountId,1885		data: CreateItemExData<T::CrossAccountId>,1886		nesting_budget: &dyn Budget,1887	) -> DispatchResultWithPostInfo;18881889	/// Burn token.1890	///1891	/// * `sender` - The user who owns the token.1892	/// * `token` - Token id that will burned.1893	/// * `amount` - The number of parts of the token that will be burned.1894	fn burn_item(1895		&self,1896		sender: T::CrossAccountId,1897		token: TokenId,1898		amount: u128,1899	) -> DispatchResultWithPostInfo;19001901	/// Burn token and all nested tokens recursievly.1902	///1903	/// * `sender` - The user who owns the token.1904	/// * `token` - Token id that will burned.1905	/// * `self_budget` - The budget that can be spent on burning tokens.1906	/// * `breadth_budget` - The budget that can be spent on burning nested tokens.1907	fn burn_item_recursively(1908		&self,1909		sender: T::CrossAccountId,1910		token: TokenId,1911		self_budget: &dyn Budget,1912		breadth_budget: &dyn Budget,1913	) -> DispatchResultWithPostInfo;19141915	/// Set collection properties.1916	///1917	/// * `sender` - Must be either the owner of the collection or its admin.1918	/// * `properties` - Properties to be set.1919	fn set_collection_properties(1920		&self,1921		sender: T::CrossAccountId,1922		properties: Vec<Property>,1923	) -> DispatchResultWithPostInfo;19241925	/// Delete collection properties.1926	///1927	/// * `sender` - Must be either the owner of the collection or its admin.1928	/// * `properties` - The properties to be removed.1929	fn delete_collection_properties(1930		&self,1931		sender: &T::CrossAccountId,1932		property_keys: Vec<PropertyKey>,1933	) -> DispatchResultWithPostInfo;19341935	/// Set token properties.1936	///1937	/// The appropriate [`PropertyPermission`] for the token property1938	/// must be set with [`Self::set_token_property_permissions`].1939	///1940	/// * `sender` - Must be either the owner of the token or its admin.1941	/// * `token_id` - The token for which the properties are being set.1942	/// * `properties` - Properties to be set.1943	/// * `budget` - Budget for setting properties.1944	fn set_token_properties(1945		&self,1946		sender: T::CrossAccountId,1947		token_id: TokenId,1948		properties: Vec<Property>,1949		budget: &dyn Budget,1950	) -> DispatchResultWithPostInfo;19511952	/// Remove token properties.1953	///1954	/// The appropriate [`PropertyPermission`] for the token property1955	/// must be set with [`Self::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 remove.1959	/// * `property_keys` - Keys to remove corresponding properties.1960	/// * `budget` - Budget for removing properties.1961	fn delete_token_properties(1962		&self,1963		sender: T::CrossAccountId,1964		token_id: TokenId,1965		property_keys: Vec<PropertyKey>,1966		budget: &dyn Budget,1967	) -> DispatchResultWithPostInfo;19681969	/// Set token property permissions.1970	///1971	/// * `sender` - Must be either the owner of the token or its admin.1972	/// * `token_id` - The token for which the properties are being set.1973	/// * `property_permissions` - Property permissions to be set.1974	/// * `budget` - Budget for setting properties.1975	fn set_token_property_permissions(1976		&self,1977		sender: &T::CrossAccountId,1978		property_permissions: Vec<PropertyKeyPermission>,1979	) -> DispatchResultWithPostInfo;19801981	/// Transfer amount of token pieces.1982	///1983	/// * `sender` - Donor user.1984	/// * `to` - Recepient user.1985	/// * `token` - The token of which parts are being sent.1986	/// * `amount` - The number of parts of the token that will be transferred.1987	/// * `budget` - The maximum budget that can be spent on the transfer.1988	fn transfer(1989		&self,1990		sender: T::CrossAccountId,1991		to: T::CrossAccountId,1992		token: TokenId,1993		amount: u128,1994		budget: &dyn Budget,1995	) -> DispatchResultWithPostInfo;19961997	/// Grant access to another account to transfer parts of the token owned by the calling user via [Self::transfer_from].1998	///1999	/// * `sender` - The user who grants access to the token.2000	/// * `spender` - The user to whom the rights are granted.2001	/// * `token` - The token to which access is granted.2002	/// * `amount` - The amount of pieces that another user can dispose of.2003	fn approve(2004		&self,2005		sender: T::CrossAccountId,2006		spender: T::CrossAccountId,2007		token: TokenId,2008		amount: u128,2009	) -> DispatchResultWithPostInfo;20102011	/// Send parts of a token owned by another user.2012	///2013	/// Before calling this method, you must grant rights to the calling user via [`Self::approve`].2014	///2015	/// * `sender` - The user who must have access to the token (see [`Self::approve`]).2016	/// * `from` - The user who owns the token.2017	/// * `to` - Recepient user.2018	/// * `token` - The token of which parts are being sent.2019	/// * `amount` - The number of parts of the token that will be transferred.2020	/// * `budget` - The maximum budget that can be spent on the transfer.2021	fn transfer_from(2022		&self,2023		sender: T::CrossAccountId,2024		from: T::CrossAccountId,2025		to: T::CrossAccountId,2026		token: TokenId,2027		amount: u128,2028		budget: &dyn Budget,2029	) -> DispatchResultWithPostInfo;20302031	/// Burn parts of a token owned by another user.2032	///2033	/// Before calling this method, you must grant rights to the calling user via [`Self::approve`].2034	///2035	/// * `sender` - The user who must have access to the token (see [`Self::approve`]).2036	/// * `from` - The user who owns the token.2037	/// * `token` - The token of which parts are being sent.2038	/// * `amount` - The number of parts of the token that will be transferred.2039	/// * `budget` - The maximum budget that can be spent on the burn.2040	fn burn_from(2041		&self,2042		sender: T::CrossAccountId,2043		from: T::CrossAccountId,2044		token: TokenId,2045		amount: u128,2046		budget: &dyn Budget,2047	) -> DispatchResultWithPostInfo;20482049	/// Check permission to nest token.2050	///2051	/// * `sender` - The user who initiated the check.2052	/// * `from` - The token that is checked for embedding.2053	/// * `under` - Token under which to check.2054	/// * `budget` - The maximum budget that can be spent on the check.2055	fn check_nesting(2056		&self,2057		sender: T::CrossAccountId,2058		from: (CollectionId, TokenId),2059		under: TokenId,2060		budget: &dyn Budget,2061	) -> DispatchResult;20622063	/// Nest one token into another.2064	///2065	/// * `under` - Token holder.2066	/// * `to_nest` - Nested token.2067	fn nest(&self, under: TokenId, to_nest: (CollectionId, TokenId));20682069	/// Unnest token.2070	///2071	/// * `under` - Token holder.2072	/// * `to_nest` - Token to unnest.2073	fn unnest(&self, under: TokenId, to_nest: (CollectionId, TokenId));20742075	/// Get all user tokens.2076	///2077	/// * `account` - Account for which you need to get tokens.2078	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId>;20792080	/// Get all the tokens in the collection.2081	fn collection_tokens(&self) -> Vec<TokenId>;20822083	/// Check if the token exists.2084	///2085	/// * `token` - Id token to check.2086	fn token_exists(&self, token: TokenId) -> bool;20872088	/// Get the id of the last minted token.2089	fn last_token_id(&self) -> TokenId;20902091	/// Get the owner of the token.2092	///2093	/// * `token` - The token for which you need to find out the owner.2094	fn token_owner(&self, token: TokenId) -> Option<T::CrossAccountId>;20952096	/// Returns 10 tokens owners in no particular order.2097	///2098	/// * `token` - The token for which you need to find out the owners.2099	fn token_owners(&self, token: TokenId) -> Vec<T::CrossAccountId>;21002101	/// Get the value of the token property by key.2102	///2103	/// * `token` - Token with the property to get.2104	/// * `key` - Property name.2105	fn token_property(&self, token_id: TokenId, key: &PropertyKey) -> Option<PropertyValue>;21062107	/// Get a set of token properties by key vector.2108	///2109	/// * `token` - Token with the property to get.2110	/// * `keys` - Vector of property keys. If this parameter is [None](sp_std::result::Result),2111	/// then all properties are returned.2112	fn token_properties(&self, token: TokenId, keys: Option<Vec<PropertyKey>>) -> Vec<Property>;21132114	/// Amount of unique collection tokens2115	fn total_supply(&self) -> u32;21162117	/// Amount of different tokens account has.2118	///2119	/// * `account` - The account for which need to get the balance.2120	fn account_balance(&self, account: T::CrossAccountId) -> u32;21212122	/// Amount of specific token account have.2123	fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128;21242125	/// Amount of token pieces2126	fn total_pieces(&self, token: TokenId) -> Option<u128>;21272128	/// Get the number of parts of the token that a trusted user can manage.2129	///2130	/// * `sender` - Trusted user.2131	/// * `spender` - Owner of the token.2132	/// * `token` - The token for which to get the value.2133	fn allowance(2134		&self,2135		sender: T::CrossAccountId,2136		spender: T::CrossAccountId,2137		token: TokenId,2138	) -> u128;21392140	/// Get extension for RFT collection.2141	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>>;21422143	/// The `operator` is allowed to transfer all tokens of the `owner` on their behalf.2144	/// * `owner` - Token owner2145	/// * `operator` - Operator2146	/// * `approve` - Should operator status be granted or revoked?2147	fn set_allowance_for_all(2148		&self,2149		owner: T::CrossAccountId,2150		operator: T::CrossAccountId,2151		approve: bool,2152	) -> DispatchResultWithPostInfo;21532154	/// Tells whether the given `owner` approves the `operator`.2155	fn allowance_for_all(&self, owner: T::CrossAccountId, operator: T::CrossAccountId) -> bool;21562157	/// Repairs a possibly broken item.2158	fn repair_item(&self, token: TokenId) -> DispatchResultWithPostInfo;2159}21602161/// Extension for RFT collection.2162pub trait RefungibleExtensions<T>2163where2164	T: Config,2165{2166	/// Change the number of parts of the token.2167	///2168	/// When the value changes down, this function is equivalent to burning parts of the token.2169	///2170	/// * `sender` - The user calling the repartition operation. Must be the owner of the token.2171	/// * `token` - The token for which you want to change the number of parts.2172	/// * `amount` - The new value of the parts of the token.2173	fn repartition(2174		&self,2175		sender: &T::CrossAccountId,2176		token: TokenId,2177		amount: u128,2178	) -> DispatchResultWithPostInfo;2179}21802181/// Merge [`DispatchResult`] with [`Weight`] into [`DispatchResultWithPostInfo`].2182///2183/// Used for [`CommonCollectionOperations`] implementations and flexible enough to do so.2184pub fn with_weight(res: DispatchResult, weight: Weight) -> DispatchResultWithPostInfo {2185	let post_info = PostDispatchInfo {2186		actual_weight: Some(weight),2187		pays_fee: Pays::Yes,2188	};2189	match res {2190		Ok(()) => Ok(post_info),2191		Err(error) => Err(DispatchErrorWithPostInfo { post_info, error }),2192	}2193}21942195impl<T: Config> From<PropertiesError> for Error<T> {2196	fn from(error: PropertiesError) -> Self {2197		match error {2198			PropertiesError::NoSpaceForProperty => Self::NoSpaceForProperty,2199			PropertiesError::PropertyLimitReached => Self::PropertyLimitReached,2200			PropertiesError::InvalidCharacterInPropertyKey => Self::InvalidCharacterInPropertyKey,2201			PropertiesError::PropertyKeyIsTooLong => Self::PropertyKeyIsTooLong,2202			PropertiesError::EmptyPropertyKey => Self::EmptyPropertyKey,2203		}2204	}2205}