git.delta.rocks / unique-network / refs/commits / 761b2c7920ca

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#![cfg_attr(not(feature = "std"), no_std)]1819use core::ops::{Deref, DerefMut};20use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};21use sp_std::{vec::Vec, collections::btree_map::BTreeMap};22use pallet_evm::account::CrossAccountId;23use frame_support::{24	dispatch::{DispatchErrorWithPostInfo, DispatchResultWithPostInfo, Weight, PostDispatchInfo},25	ensure, fail,26	traits::{Imbalance, Get, Currency, WithdrawReasons, ExistenceRequirement},27	BoundedVec,28	weights::Pays,29};30use pallet_evm::GasWeightMapping;31use up_data_structs::{32	COLLECTION_NUMBER_LIMIT, Collection, RpcCollection, CollectionId, CreateItemData,33	MAX_TOKEN_PREFIX_LENGTH, COLLECTION_ADMINS_LIMIT, MetaUpdatePermission, TokenId,34	CollectionStats, MAX_TOKEN_OWNERSHIP, CollectionMode, NFT_SPONSOR_TRANSFER_TIMEOUT,35	FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT, REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT, MAX_SPONSOR_TIMEOUT,36	CUSTOM_DATA_LIMIT, CollectionLimits, CustomDataLimit, CreateCollectionData, SponsorshipState,37	CreateItemExData, SponsoringRateLimit, budget::Budget, COLLECTION_FIELD_LIMIT, CollectionField,38	PhantomType, Property, Properties, PropertiesPermissionMap, PropertyKey, PropertyPermission,39	PropertiesError, PropertyKeyPermission, TokenData,40};41pub use pallet::*;42use sp_core::H160;43use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};44#[cfg(feature = "runtime-benchmarks")]45pub mod benchmarking;46pub mod dispatch;47pub mod erc;48pub mod eth;4950#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]51pub struct CollectionHandle<T: Config> {52	pub id: CollectionId,53	collection: Collection<T::AccountId>,54	pub recorder: SubstrateRecorder<T>,55}56impl<T: Config> WithRecorder<T> for CollectionHandle<T> {57	fn recorder(&self) -> &SubstrateRecorder<T> {58		&self.recorder59	}60	fn into_recorder(self) -> SubstrateRecorder<T> {61		self.recorder62	}63}64impl<T: Config> CollectionHandle<T> {65	pub fn new_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {66		<CollectionById<T>>::get(id).map(|collection| Self {67			id,68			collection,69			recorder: SubstrateRecorder::new(eth::collection_id_to_address(id), gas_limit),70		})71	}72	pub fn new(id: CollectionId) -> Option<Self> {73		Self::new_with_gas_limit(id, u64::MAX)74	}75	pub fn try_get(id: CollectionId) -> Result<Self, DispatchError> {76		Ok(Self::new(id).ok_or(<Error<T>>::CollectionNotFound)?)77	}78	pub fn log_mirrored(&self, log: impl evm_coder::ToLog) {79		self.recorder.log_mirrored(log)80	}81	pub fn log_direct(&self, log: impl evm_coder::ToLog) {82		self.recorder.log_direct(log)83	}84	pub fn consume_store_reads(&self, reads: u64) -> evm_coder::execution::Result<()> {85		self.recorder86			.consume_gas(T::GasWeightMapping::weight_to_gas(87				<T as frame_system::Config>::DbWeight::get()88					.read89					.saturating_mul(reads),90			))91	}92	pub fn consume_store_writes(&self, writes: u64) -> evm_coder::execution::Result<()> {93		self.recorder94			.consume_gas(T::GasWeightMapping::weight_to_gas(95				<T as frame_system::Config>::DbWeight::get()96					.write97					.saturating_mul(writes),98			))99	}100	pub fn submit_logs(self) {101		self.recorder.submit_logs()102	}103	pub fn save(self) -> DispatchResult {104		self.recorder.submit_logs();105		<CollectionById<T>>::insert(self.id, self.collection);106		Ok(())107	}108}109impl<T: Config> Deref for CollectionHandle<T> {110	type Target = Collection<T::AccountId>;111112	fn deref(&self) -> &Self::Target {113		&self.collection114	}115}116117impl<T: Config> DerefMut for CollectionHandle<T> {118	fn deref_mut(&mut self) -> &mut Self::Target {119		&mut self.collection120	}121}122123impl<T: Config> CollectionHandle<T> {124	pub fn check_is_owner(&self, subject: &T::CrossAccountId) -> DispatchResult {125		ensure!(*subject.as_sub() == self.owner, <Error<T>>::NoPermission);126		Ok(())127	}128	pub fn is_owner_or_admin(&self, subject: &T::CrossAccountId) -> bool {129		*subject.as_sub() == self.owner || <IsAdmin<T>>::get((self.id, subject))130	}131	pub fn check_is_owner_or_admin(&self, subject: &T::CrossAccountId) -> DispatchResult {132		ensure!(self.is_owner_or_admin(subject), <Error<T>>::NoPermission);133		Ok(())134	}135	pub fn ignores_allowance(&self, user: &T::CrossAccountId) -> bool {136		self.limits.owner_can_transfer() && self.is_owner_or_admin(user)137	}138	pub fn ignores_owned_amount(&self, user: &T::CrossAccountId) -> bool {139		self.limits.owner_can_transfer() && self.is_owner_or_admin(user)140	}141	pub fn check_allowlist(&self, user: &T::CrossAccountId) -> DispatchResult {142		ensure!(143			<Allowlist<T>>::get((self.id, user)),144			<Error<T>>::AddressNotInAllowlist145		);146		Ok(())147	}148149	pub fn check_can_update_meta(150		&self,151		subject: &T::CrossAccountId,152		item_owner: &T::CrossAccountId,153	) -> DispatchResult {154		match self.meta_update_permission {155			MetaUpdatePermission::ItemOwner => {156				ensure!(subject == item_owner, <Error<T>>::NoPermission);157				Ok(())158			}159			MetaUpdatePermission::Admin => self.check_is_owner_or_admin(subject),160			MetaUpdatePermission::None => fail!(<Error<T>>::NoPermission),161		}162	}163}164165#[frame_support::pallet]166pub mod pallet {167	use super::*;168	use pallet_evm::account;169	use dispatch::CollectionDispatch;170	use frame_support::{Blake2_128Concat, pallet_prelude::*, storage::Key, traits::StorageVersion};171	use frame_system::pallet_prelude::*;172	use frame_support::traits::Currency;173	use up_data_structs::{TokenId, mapping::TokenAddressMapping};174	use scale_info::TypeInfo;175176	#[pallet::config]177	pub trait Config:178		frame_system::Config + pallet_evm_coder_substrate::Config + TypeInfo + account::Config179	{180		type Event: IsType<<Self as frame_system::Config>::Event> + From<Event<Self>>;181182		type Currency: Currency<Self::AccountId>;183184		#[pallet::constant]185		type CollectionCreationPrice: Get<186			<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,187		>;188		type CollectionDispatch: CollectionDispatch<Self>;189190		type TreasuryAccountId: Get<Self::AccountId>;191192		type EvmTokenAddressMapping: TokenAddressMapping<H160>;193		type CrossTokenAddressMapping: TokenAddressMapping<Self::CrossAccountId>;194	}195196	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);197198	#[pallet::pallet]199	#[pallet::storage_version(STORAGE_VERSION)]200	#[pallet::generate_store(pub(super) trait Store)]201	pub struct Pallet<T>(_);202203	#[pallet::extra_constants]204	impl<T: Config> Pallet<T> {205		pub fn collection_admins_limit() -> u32 {206			COLLECTION_ADMINS_LIMIT207		}208	}209210	#[pallet::event]211	#[pallet::generate_deposit(pub fn deposit_event)]212	pub enum Event<T: Config> {213		/// New collection was created214		///215		/// # Arguments216		///217		/// * collection_id: Globally unique identifier of newly created collection.218		///219		/// * mode: [CollectionMode] converted into u8.220		///221		/// * account_id: Collection owner.222		CollectionCreated(CollectionId, u8, T::AccountId),223224		/// New collection was destroyed225		///226		/// # Arguments227		///228		/// * collection_id: Globally unique identifier of collection.229		CollectionDestroyed(CollectionId),230231		/// New item was created.232		///233		/// # Arguments234		///235		/// * collection_id: Id of the collection where item was created.236		///237		/// * item_id: Id of an item. Unique within the collection.238		///239		/// * recipient: Owner of newly created item240		///241		/// * amount: Always 1 for NFT242		ItemCreated(CollectionId, TokenId, T::CrossAccountId, u128),243244		/// Collection item was burned.245		///246		/// # Arguments247		///248		/// * collection_id.249		///250		/// * item_id: Identifier of burned NFT.251		///252		/// * owner: which user has destroyed its tokens253		///254		/// * amount: Always 1 for NFT255		ItemDestroyed(CollectionId, TokenId, T::CrossAccountId, u128),256257		/// Item was transferred258		///259		/// * collection_id: Id of collection to which item is belong260		///261		/// * item_id: Id of an item262		///263		/// * sender: Original owner of item264		///265		/// * recipient: New owner of item266		///267		/// * amount: Always 1 for NFT268		Transfer(269			CollectionId,270			TokenId,271			T::CrossAccountId,272			T::CrossAccountId,273			u128,274		),275276		/// * collection_id277		///278		/// * item_id279		///280		/// * sender281		///282		/// * spender283		///284		/// * amount285		Approved(286			CollectionId,287			TokenId,288			T::CrossAccountId,289			T::CrossAccountId,290			u128,291		),292293		CollectionPropertySet(CollectionId, Property),294295		CollectionPropertyDeleted(CollectionId, PropertyKey),296297		TokenPropertySet(CollectionId, TokenId, Property),298299		TokenPropertyDeleted(CollectionId, TokenId, PropertyKey),300301		PropertyPermissionSet(CollectionId, PropertyKeyPermission),302	}303304	#[pallet::error]305	pub enum Error<T> {306		/// This collection does not exist.307		CollectionNotFound,308		/// Sender parameter and item owner must be equal.309		MustBeTokenOwner,310		/// No permission to perform action311		NoPermission,312		/// Collection is not in mint mode.313		PublicMintingNotAllowed,314		/// Address is not in allow list.315		AddressNotInAllowlist,316317		/// Collection name can not be longer than 63 char.318		CollectionNameLimitExceeded,319		/// Collection description can not be longer than 255 char.320		CollectionDescriptionLimitExceeded,321		/// Token prefix can not be longer than 15 char.322		CollectionTokenPrefixLimitExceeded,323		/// Total collections bound exceeded.324		TotalCollectionsLimitExceeded,325		/// variable_data exceeded data limit.326		TokenVariableDataLimitExceeded,327		/// Exceeded max admin count328		CollectionAdminCountExceeded,329		/// Collection limit bounds per collection exceeded330		CollectionLimitBoundsExceeded,331		/// Tried to enable permissions which are only permitted to be disabled332		OwnerPermissionsCantBeReverted,333		/// Collection settings not allowing items transferring334		TransferNotAllowed,335		/// Account token limit exceeded per collection336		AccountTokenLimitExceeded,337		/// Collection token limit exceeded338		CollectionTokenLimitExceeded,339		/// Metadata flag frozen340		MetadataFlagFrozen,341342		/// Item not exists.343		TokenNotFound,344		/// Item balance not enough.345		TokenValueTooLow,346		/// Requested value more than approved.347		ApprovedValueTooLow,348		/// Tried to approve more than owned349		CantApproveMoreThanOwned,350351		/// Can't transfer tokens to ethereum zero address352		AddressIsZero,353		/// Target collection doesn't supports this operation354		UnsupportedOperation,355356		/// Not sufficient founds to perform action357		NotSufficientFounds,358359		/// Collection has nesting disabled360		NestingIsDisabled,361		/// Only owner may nest tokens under this collection362		OnlyOwnerAllowedToNest,363		/// Only tokens from specific collections may nest tokens under this364		SourceCollectionIsNotAllowedToNest,365366		/// Tried to store more data than allowed in collection field367		CollectionFieldSizeExceeded,368369		NoSpaceForProperty,370371		PropertyLimitReached,372	}373374	#[pallet::storage]375	pub type CreatedCollectionCount<T> = StorageValue<Value = CollectionId, QueryKind = ValueQuery>;376	#[pallet::storage]377	pub type DestroyedCollectionCount<T> =378		StorageValue<Value = CollectionId, QueryKind = ValueQuery>;379380	/// Collection info381	#[pallet::storage]382	pub type CollectionById<T> = StorageMap<383		Hasher = Blake2_128Concat,384		Key = CollectionId,385		Value = Collection<<T as frame_system::Config>::AccountId>,386		QueryKind = OptionQuery,387	>;388389	/// Collection properties390	#[pallet::storage]391	#[pallet::getter(fn collection_properties)]392	pub type CollectionProperties<T> = StorageMap<393		Hasher = Blake2_128Concat,394		Key = CollectionId,395		Value = Properties,396		QueryKind = ValueQuery,397		OnEmpty = up_data_structs::CollectionProperties,398	>;399400	#[pallet::storage]401	#[pallet::getter(fn property_permissions)]402	pub type CollectionPropertyPermissions<T> = StorageMap<403		Hasher = Blake2_128Concat,404		Key = CollectionId,405		Value = PropertiesPermissionMap,406		QueryKind = ValueQuery,407	>;408409	/// Large variable-size collection fields are extracted here410	#[pallet::storage]411	pub type CollectionData<T> = StorageNMap<412		Key = (413			Key<Twox64Concat, CollectionId>,414			Key<Twox64Concat, CollectionField>,415		),416		Value = BoundedVec<u8, ConstU32<COLLECTION_FIELD_LIMIT>>,417		QueryKind = ValueQuery,418	>;419420	#[pallet::storage]421	pub type AdminAmount<T> = StorageMap<422		Hasher = Blake2_128Concat,423		Key = CollectionId,424		Value = u32,425		QueryKind = ValueQuery,426	>;427428	/// List of collection admins429	#[pallet::storage]430	pub type IsAdmin<T: Config> = StorageNMap<431		Key = (432			Key<Blake2_128Concat, CollectionId>,433			Key<Blake2_128Concat, T::CrossAccountId>,434		),435		Value = bool,436		QueryKind = ValueQuery,437	>;438439	/// Allowlisted collection users440	#[pallet::storage]441	pub type Allowlist<T: Config> = StorageNMap<442		Key = (443			Key<Blake2_128Concat, CollectionId>,444			Key<Blake2_128Concat, T::CrossAccountId>,445		),446		Value = bool,447		QueryKind = ValueQuery,448	>;449450	/// Not used by code, exists only to provide some types to metadata451	#[pallet::storage]452	pub type DummyStorageValue<T: Config> = StorageValue<453		Value = (454			CollectionStats,455			CollectionId,456			TokenId,457			PhantomType<TokenData<T::CrossAccountId>>,458			PhantomType<RpcCollection<T::AccountId>>,459		),460		QueryKind = OptionQuery,461	>;462463	#[pallet::hooks]464	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {465		fn on_runtime_upgrade() -> Weight {466			if StorageVersion::get::<Pallet<T>>() < StorageVersion::new(1) {467				use up_data_structs::{CollectionVersion1, CollectionVersion2};468				<CollectionById<T>>::translate::<CollectionVersion1<T::AccountId>, _>(|id, v| {469					Self::set_field_raw(470						id,471						CollectionField::OffchainSchema,472						v.offchain_schema.clone().into_inner(),473					)474					.expect("data has lower bounds than field");475					Self::set_field_raw(476						id,477						CollectionField::VariableOnChainSchema,478						v.variable_on_chain_schema.clone().into_inner(),479					)480					.expect("data has lower bounds than field");481					Self::set_field_raw(482						id,483						CollectionField::ConstOnChainSchema,484						v.const_on_chain_schema.clone().into_inner(),485					)486					.expect("data has lower bounds than field");487488					Some(CollectionVersion2::from(v))489				});490			}491492			0493		}494	}495}496497impl<T: Config> Pallet<T> {498	/// Ethereum receiver 0x0000000000000000000000000000000000000000 is reserved, and shouldn't own tokens499	pub fn ensure_correct_receiver(receiver: &T::CrossAccountId) -> DispatchResult {500		ensure!(501			&T::CrossAccountId::from_eth(H160([0; 20])) != receiver,502			<Error<T>>::AddressIsZero503		);504		Ok(())505	}506	pub fn adminlist(collection: CollectionId) -> Vec<T::CrossAccountId> {507		<IsAdmin<T>>::iter_prefix((collection,))508			.map(|(a, _)| a)509			.collect()510	}511	pub fn allowlist(collection: CollectionId) -> Vec<T::CrossAccountId> {512		<Allowlist<T>>::iter_prefix((collection,))513			.map(|(a, _)| a)514			.collect()515	}516	pub fn allowed(collection: CollectionId, user: T::CrossAccountId) -> bool {517		<Allowlist<T>>::get((collection, user))518	}519	pub fn collection_stats() -> CollectionStats {520		let created = <CreatedCollectionCount<T>>::get();521		let destroyed = <DestroyedCollectionCount<T>>::get();522		CollectionStats {523			created: created.0,524			destroyed: destroyed.0,525			alive: created.0 - destroyed.0,526		}527	}528529	pub fn effective_collection_limits(collection: CollectionId) -> Option<CollectionLimits> {530		let collection = <CollectionById<T>>::get(collection);531		if collection.is_none() {532			return None;533		}534535		let collection = collection.unwrap();536		let limits = collection.limits;537		let effective_limits = CollectionLimits {538			account_token_ownership_limit: Some(limits.account_token_ownership_limit()),539			sponsored_data_size: Some(limits.sponsored_data_size()),540			sponsored_data_rate_limit: Some(541				limits542					.sponsored_data_rate_limit543					.unwrap_or(SponsoringRateLimit::SponsoringDisabled),544			),545			token_limit: Some(limits.token_limit()),546			sponsor_transfer_timeout: Some(limits.sponsor_transfer_timeout(547				match collection.mode {548					CollectionMode::NFT => NFT_SPONSOR_TRANSFER_TIMEOUT,549					CollectionMode::Fungible(_) => FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,550					CollectionMode::ReFungible => REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,551				},552			)),553			sponsor_approve_timeout: Some(limits.sponsor_approve_timeout()),554			owner_can_transfer: Some(limits.owner_can_transfer()),555			owner_can_destroy: Some(limits.owner_can_destroy()),556			transfers_enabled: Some(limits.transfers_enabled()),557			nesting_rule: Some(limits.nesting_rule().clone()),558		};559560		Some(effective_limits)561	}562563	pub fn rpc_collection(collection: CollectionId) -> Option<RpcCollection<T::AccountId>> {564		let Collection {565			name,566			description,567			owner,568			mode,569			access,570			token_prefix,571			mint_mode,572			schema_version,573			sponsorship,574			limits,575			meta_update_permission,576			..577		} = <CollectionById<T>>::get(collection)?;578		Some(RpcCollection {579			name: name.into_inner(),580			description: description.into_inner(),581			owner,582			mode,583			access,584			token_prefix: token_prefix.into_inner(),585			mint_mode,586			schema_version,587			sponsorship,588			limits,589			meta_update_permission,590			offchain_schema: <CollectionData<T>>::get((591				collection,592				CollectionField::OffchainSchema,593			))594			.into_inner(),595			const_on_chain_schema: <CollectionData<T>>::get((596				collection,597				CollectionField::ConstOnChainSchema,598			))599			.into_inner(),600			variable_on_chain_schema: <CollectionData<T>>::get((601				collection,602				CollectionField::VariableOnChainSchema,603			))604			.into_inner(),605		})606	}607}608609impl<T: Config> Pallet<T> {610	pub fn init_collection(611		owner: T::AccountId,612		data: CreateCollectionData<T::AccountId>,613	) -> Result<CollectionId, DispatchError> {614		{615			ensure!(616				data.token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH as usize,617				Error::<T>::CollectionTokenPrefixLimitExceeded618			);619		}620621		let created_count = <CreatedCollectionCount<T>>::get()622			.0623			.checked_add(1)624			.ok_or(ArithmeticError::Overflow)?;625		let destroyed_count = <DestroyedCollectionCount<T>>::get().0;626		let id = CollectionId(created_count);627628		// bound Total number of collections629		ensure!(630			created_count - destroyed_count <= COLLECTION_NUMBER_LIMIT,631			<Error<T>>::TotalCollectionsLimitExceeded632		);633634		// =========635636		let collection = Collection {637			owner: owner.clone(),638			name: data.name,639			mode: data.mode.clone(),640			mint_mode: false,641			access: data.access.unwrap_or_default(),642			description: data.description,643			token_prefix: data.token_prefix,644			schema_version: data.schema_version.unwrap_or_default(),645			sponsorship: data646				.pending_sponsor647				.map(SponsorshipState::Unconfirmed)648				.unwrap_or_default(),649			limits: data650				.limits651				.map(|limits| Self::clamp_limits(data.mode.clone(), &Default::default(), limits))652				.unwrap_or_else(|| Ok(CollectionLimits::default()))?,653			meta_update_permission: data.meta_update_permission.unwrap_or_default(),654			// token_property_permissions: data.token_property_permissions.unwrap_or_default(),655			// properties: Properties::from_collection_props_vec(data.properties)?656		};657658		CollectionProperties::<T>::insert(659			id,660			Properties::from_collection_props_vec(data.properties)661				.map_err(|e| -> Error<T> { e.into() })?,662		);663664		let token_props_permissions: PropertiesPermissionMap = data665			.token_property_permissions666			.into_iter()667			.map(|property| (property.key, property.permission))668			.collect::<BTreeMap<_, _>>()669			.try_into()670			.map_err(|_| -> Error<T> { PropertiesError::PropertyLimitReached.into() })?;671672		CollectionPropertyPermissions::<T>::insert(id, token_props_permissions);673674		// Take a (non-refundable) deposit of collection creation675		{676			let mut imbalance =677				<<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();678			imbalance.subsume(679				<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(680					&T::TreasuryAccountId::get(),681					T::CollectionCreationPrice::get(),682				),683			);684			<T as Config>::Currency::settle(685				&owner,686				imbalance,687				WithdrawReasons::TRANSFER,688				ExistenceRequirement::KeepAlive,689			)690			.map_err(|_| Error::<T>::NotSufficientFounds)?;691		}692693		<CreatedCollectionCount<T>>::put(created_count);694		<Pallet<T>>::deposit_event(Event::CollectionCreated(id, data.mode.id(), owner.clone()));695		<CollectionById<T>>::insert(id, collection);696		Self::set_field_raw(697			id,698			CollectionField::OffchainSchema,699			data.offchain_schema.into_inner(),700		)701		.expect("data has lower bounds than field");702		Self::set_field_raw(703			id,704			CollectionField::VariableOnChainSchema,705			data.variable_on_chain_schema.into_inner(),706		)707		.expect("data has lower bounds than field");708		Self::set_field_raw(709			id,710			CollectionField::ConstOnChainSchema,711			data.const_on_chain_schema.into_inner(),712		)713		.expect("data has lower bounds than field");714		Ok(id)715	}716717	pub fn destroy_collection(718		collection: CollectionHandle<T>,719		sender: &T::CrossAccountId,720	) -> DispatchResult {721		ensure!(722			collection.limits.owner_can_destroy(),723			<Error<T>>::NoPermission,724		);725		collection.check_is_owner(sender)?;726727		let destroyed_collections = <DestroyedCollectionCount<T>>::get()728			.0729			.checked_add(1)730			.ok_or(ArithmeticError::Overflow)?;731732		// =========733734		<DestroyedCollectionCount<T>>::put(destroyed_collections);735		<CollectionById<T>>::remove(collection.id);736		<CollectionData<T>>::remove_prefix((collection.id,), None);737		<AdminAmount<T>>::remove(collection.id);738		<IsAdmin<T>>::remove_prefix((collection.id,), None);739		<Allowlist<T>>::remove_prefix((collection.id,), None);740741		<Pallet<T>>::deposit_event(Event::CollectionDestroyed(collection.id));742		Ok(())743	}744745	pub fn set_collection_property(746		collection: &CollectionHandle<T>,747		sender: &T::CrossAccountId,748		property: Property,749	) -> DispatchResult {750		collection.check_is_owner_or_admin(sender)?;751752		CollectionProperties::<T>::try_mutate(collection.id, |properties| {753			properties.try_set_property(property.clone())754		})755		.map_err(|e| -> Error<T> { e.into() })?;756757		Self::deposit_event(Event::CollectionPropertySet(collection.id, property));758759		Ok(())760	}761762	pub fn set_collection_properties(763		collection: &CollectionHandle<T>,764		sender: &T::CrossAccountId,765		properties: Vec<Property>,766	) -> DispatchResult {767		for property in properties {768			Self::set_collection_property(collection, sender, property)?;769		}770771		Ok(())772	}773774	pub fn delete_collection_property(775		collection: &CollectionHandle<T>,776		sender: &T::CrossAccountId,777		property_key: PropertyKey,778	) -> DispatchResult {779		collection.check_is_owner_or_admin(sender)?;780781		CollectionProperties::<T>::mutate(collection.id, |properties| {782			properties.remove_property(&property_key);783		});784785		Self::deposit_event(Event::CollectionPropertyDeleted(786			collection.id,787			property_key,788		));789790		Ok(())791	}792793	pub fn delete_collection_properties(794		collection: &CollectionHandle<T>,795		sender: &T::CrossAccountId,796		property_keys: Vec<PropertyKey>,797	) -> DispatchResult {798		for key in property_keys {799			Self::delete_collection_property(collection, sender, key)?;800		}801802		Ok(())803	}804805	pub fn set_property_permission(806		collection: &CollectionHandle<T>,807		sender: &T::CrossAccountId,808		property_permission: PropertyKeyPermission,809	) -> DispatchResult {810		collection.check_is_owner_or_admin(sender)?;811812		let all_permissions = CollectionPropertyPermissions::<T>::get(collection.id);813		let current_permission = all_permissions.get(&property_permission.key);814		if matches![815			current_permission,816			Some(PropertyPermission { mutable: false, .. })817		] {818			return Err(<Error<T>>::NoPermission.into());819		}820821		CollectionPropertyPermissions::<T>::try_mutate(collection.id, |permissions| {822			let property_permission = property_permission.clone();823			permissions.try_insert(property_permission.key, property_permission.permission)824		})825		.map_err(|_| -> Error<T> { PropertiesError::PropertyLimitReached.into() })?;826827		Self::deposit_event(Event::PropertyPermissionSet(828			collection.id,829			property_permission,830		));831832		Ok(())833	}834835	pub fn set_property_permissions(836		collection: &CollectionHandle<T>,837		sender: &T::CrossAccountId,838		property_permissions: Vec<PropertyKeyPermission>,839	) -> DispatchResult {840		for prop_pemission in property_permissions {841			Self::set_property_permission(collection, sender, prop_pemission)?;842		}843844		Ok(())845	}846847	pub fn bytes_keys_to_property_keys(keys: Vec<Vec<u8>>) -> Result<Vec<PropertyKey>, DispatchError> {848		keys.into_iter()849			.map(|key| -> Result<PropertyKey, DispatchError> {850				// TODO Fix error851				key.try_into().map_err(|_| DispatchError::Other("Can't read property key"))852			})853			.collect::<Result<Vec<PropertyKey>, DispatchError>>()854	}855856	pub fn filter_collection_properties(857		collection_id: CollectionId,858		keys: Vec<PropertyKey>859	) -> Result<Vec<Property>, DispatchError> {860		let properties = Self::collection_properties(collection_id);861862		let properties = keys.into_iter()863			.filter_map(|key| {864				properties.get_property(&key)865					.map(|value| {866						Property {867							key,868							value: value.clone()869						}870					})871			})872			.collect();873874		Ok(properties)875	}876877	pub fn filter_property_permissions(878		collection_id: CollectionId,879		keys: Vec<PropertyKey>880	) -> Result<Vec<PropertyKeyPermission>, DispatchError> {881		let permissions = Self::property_permissions(collection_id);882883		let key_permissions = keys.into_iter()884			.filter_map(|key| {885				permissions.get(&key)886					.map(|permission| {887						PropertyKeyPermission {888							key,889							permission: permission.clone()890						}891					})892			})893			.collect();894895		Ok(key_permissions)896	}897898	fn set_field_raw(899		collection_id: CollectionId,900		field: CollectionField,901		value: Vec<u8>,902	) -> DispatchResult {903		if !value.is_empty() {904			<CollectionData<T>>::insert(905				(collection_id, field),906				BoundedVec::try_from(value).map_err(|_| <Error<T>>::CollectionFieldSizeExceeded)?,907			)908		} else {909			<CollectionData<T>>::remove((collection_id, field));910		}911		Ok(())912	}913914	pub fn set_field(915		collection: &CollectionHandle<T>,916		sender: &T::CrossAccountId,917		field: CollectionField,918		value: Vec<u8>,919	) -> DispatchResult {920		collection.check_is_owner_or_admin(sender)?;921922		// =========923924		Self::set_field_raw(collection.id, field, value)925	}926927	pub fn toggle_allowlist(928		collection: &CollectionHandle<T>,929		sender: &T::CrossAccountId,930		user: &T::CrossAccountId,931		allowed: bool,932	) -> DispatchResult {933		collection.check_is_owner_or_admin(sender)?;934935		// =========936937		if allowed {938			<Allowlist<T>>::insert((collection.id, user), true);939		} else {940			<Allowlist<T>>::remove((collection.id, user));941		}942943		Ok(())944	}945946	pub fn toggle_admin(947		collection: &CollectionHandle<T>,948		sender: &T::CrossAccountId,949		user: &T::CrossAccountId,950		admin: bool,951	) -> DispatchResult {952		collection.check_is_owner_or_admin(sender)?;953954		let was_admin = <IsAdmin<T>>::get((collection.id, user));955		if was_admin == admin {956			return Ok(());957		}958		let amount = <AdminAmount<T>>::get(collection.id);959960		if admin {961			let amount = amount962				.checked_add(1)963				.ok_or(<Error<T>>::CollectionAdminCountExceeded)?;964			ensure!(965				amount <= Self::collection_admins_limit(),966				<Error<T>>::CollectionAdminCountExceeded,967			);968969			// =========970971			<AdminAmount<T>>::insert(collection.id, amount);972			<IsAdmin<T>>::insert((collection.id, user), true);973		} else {974			<AdminAmount<T>>::insert(collection.id, amount.saturating_sub(1));975			<IsAdmin<T>>::remove((collection.id, user));976		}977978		Ok(())979	}980981	pub fn clamp_limits(982		mode: CollectionMode,983		old_limit: &CollectionLimits,984		mut new_limit: CollectionLimits,985	) -> Result<CollectionLimits, DispatchError> {986		macro_rules! limit_default {987				($old:ident, $new:ident, $($field:ident $(($arg:expr))? => $check:expr),* $(,)?) => {{988					$(989						if let Some($new) = $new.$field {990							let $old = $old.$field($($arg)?);991							let _ = $new;992							let _ = $old;993							$check994						} else {995							$new.$field = $old.$field996						}997					)*998				}};999			}10001001		limit_default!(old_limit, new_limit,1002			account_token_ownership_limit => ensure!(1003				new_limit <= MAX_TOKEN_OWNERSHIP,1004				<Error<T>>::CollectionLimitBoundsExceeded,1005			),1006			sponsor_transfer_timeout(match mode {1007				CollectionMode::NFT => NFT_SPONSOR_TRANSFER_TIMEOUT,1008				CollectionMode::Fungible(_) => FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,1009				CollectionMode::ReFungible => REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,1010			}) => ensure!(1011				new_limit <= MAX_SPONSOR_TIMEOUT,1012				<Error<T>>::CollectionLimitBoundsExceeded,1013			),1014			sponsored_data_size => ensure!(1015				new_limit <= CUSTOM_DATA_LIMIT,1016				<Error<T>>::CollectionLimitBoundsExceeded,1017			),1018			token_limit => ensure!(1019				old_limit >= new_limit && new_limit > 0,1020				<Error<T>>::CollectionTokenLimitExceeded1021			),1022			owner_can_transfer => ensure!(1023				old_limit || !new_limit,1024				<Error<T>>::OwnerPermissionsCantBeReverted,1025			),1026			owner_can_destroy => ensure!(1027				old_limit || !new_limit,1028				<Error<T>>::OwnerPermissionsCantBeReverted,1029			),1030			sponsored_data_rate_limit => {},1031			transfers_enabled => {},1032		);1033		Ok(new_limit)1034	}1035}10361037#[macro_export]1038macro_rules! unsupported {1039	() => {1040		Err(<Error<T>>::UnsupportedOperation.into())1041	};1042}10431044/// Worst cases1045pub trait CommonWeightInfo<CrossAccountId> {1046	fn create_item() -> Weight;1047	fn create_multiple_items(amount: u32) -> Weight;1048	fn create_multiple_items_ex(cost: &CreateItemExData<CrossAccountId>) -> Weight;1049	fn burn_item() -> Weight;1050	fn set_collection_properties(amount: u32) -> Weight;1051	fn delete_collection_properties(amount: u32) -> Weight;1052	fn set_token_properties(amount: u32) -> Weight;1053	fn delete_token_properties(amount: u32) -> Weight;1054	fn set_property_permissions(amount: u32) -> Weight;1055	fn transfer() -> Weight;1056	fn approve() -> Weight;1057	fn transfer_from() -> Weight;1058	fn burn_from() -> Weight;1059	fn set_variable_metadata(bytes: u32) -> Weight;1060}10611062pub trait CommonCollectionOperations<T: Config> {1063	fn create_item(1064		&self,1065		sender: T::CrossAccountId,1066		to: T::CrossAccountId,1067		data: CreateItemData,1068		nesting_budget: &dyn Budget,1069	) -> DispatchResultWithPostInfo;1070	fn create_multiple_items(1071		&self,1072		sender: T::CrossAccountId,1073		to: T::CrossAccountId,1074		data: Vec<CreateItemData>,1075		nesting_budget: &dyn Budget,1076	) -> DispatchResultWithPostInfo;1077	fn create_multiple_items_ex(1078		&self,1079		sender: T::CrossAccountId,1080		data: CreateItemExData<T::CrossAccountId>,1081		nesting_budget: &dyn Budget,1082	) -> DispatchResultWithPostInfo;1083	fn burn_item(1084		&self,1085		sender: T::CrossAccountId,1086		token: TokenId,1087		amount: u128,1088	) -> DispatchResultWithPostInfo;1089	fn set_collection_properties(1090		&self,1091		sender: T::CrossAccountId,1092		properties: Vec<Property>,1093	) -> DispatchResultWithPostInfo;1094	fn delete_collection_properties(1095		&self,1096		sender: &T::CrossAccountId,1097		property_keys: Vec<PropertyKey>,1098	) -> DispatchResultWithPostInfo;1099	fn set_token_properties(1100		&self,1101		sender: T::CrossAccountId,1102		token_id: TokenId,1103		property: Vec<Property>,1104	) -> DispatchResultWithPostInfo;1105	fn delete_token_properties(1106		&self,1107		sender: T::CrossAccountId,1108		token_id: TokenId,1109		property_keys: Vec<PropertyKey>,1110	) -> DispatchResultWithPostInfo;1111	fn set_property_permissions(1112		&self,1113		sender: &T::CrossAccountId,1114		property_permissions: Vec<PropertyKeyPermission>,1115	) -> DispatchResultWithPostInfo;1116	fn transfer(1117		&self,1118		sender: T::CrossAccountId,1119		to: T::CrossAccountId,1120		token: TokenId,1121		amount: u128,1122		nesting_budget: &dyn Budget,1123	) -> DispatchResultWithPostInfo;1124	fn approve(1125		&self,1126		sender: T::CrossAccountId,1127		spender: T::CrossAccountId,1128		token: TokenId,1129		amount: u128,1130	) -> DispatchResultWithPostInfo;1131	fn transfer_from(1132		&self,1133		sender: T::CrossAccountId,1134		from: T::CrossAccountId,1135		to: T::CrossAccountId,1136		token: TokenId,1137		amount: u128,1138		nesting_budget: &dyn Budget,1139	) -> DispatchResultWithPostInfo;1140	fn burn_from(1141		&self,1142		sender: T::CrossAccountId,1143		from: T::CrossAccountId,1144		token: TokenId,1145		amount: u128,1146		nesting_budget: &dyn Budget,1147	) -> DispatchResultWithPostInfo;11481149	fn set_variable_metadata(1150		&self,1151		sender: T::CrossAccountId,1152		token: TokenId,1153		data: BoundedVec<u8, CustomDataLimit>,1154	) -> DispatchResultWithPostInfo;11551156	fn check_nesting(1157		&self,1158		sender: T::CrossAccountId,1159		from: (CollectionId, TokenId),1160		under: TokenId,1161		budget: &dyn Budget,1162	) -> DispatchResult;11631164	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId>;1165	fn collection_tokens(&self) -> Vec<TokenId>;1166	fn token_exists(&self, token: TokenId) -> bool;1167	fn last_token_id(&self) -> TokenId;11681169	fn token_owner(&self, token: TokenId) -> Option<T::CrossAccountId>;1170	fn const_metadata(&self, token: TokenId) -> Vec<u8>;1171	fn variable_metadata(&self, token: TokenId) -> Vec<u8>;1172	fn token_properties(1173		&self,1174		token_id: TokenId,1175		keys: Vec<PropertyKey>1176	) -> Vec<Property>;1177	/// Amount of unique collection tokens1178	fn total_supply(&self) -> u32;1179	/// Amount of different tokens account has (Applicable to nonfungible/refungible)1180	fn account_balance(&self, account: T::CrossAccountId) -> u32;1181	/// Amount of specific token account have (Applicable to fungible/refungible)1182	fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128;1183	fn allowance(1184		&self,1185		sender: T::CrossAccountId,1186		spender: T::CrossAccountId,1187		token: TokenId,1188	) -> u128;1189}11901191// Flexible enough for implementing CommonCollectionOperations1192pub fn with_weight(res: DispatchResult, weight: Weight) -> DispatchResultWithPostInfo {1193	let post_info = PostDispatchInfo {1194		actual_weight: Some(weight),1195		pays_fee: Pays::Yes,1196	};1197	match res {1198		Ok(()) => Ok(post_info),1199		Err(error) => Err(DispatchErrorWithPostInfo { post_info, error }),1200	}1201}12021203impl<T: Config> From<PropertiesError> for Error<T> {1204	fn from(error: PropertiesError) -> Self {1205		match error {1206			PropertiesError::NoSpaceForProperty => Self::NoSpaceForProperty,1207			PropertiesError::PropertyLimitReached => Self::PropertyLimitReached,1208		}1209	}1210}