git.delta.rocks / unique-network / refs/commits / 5013d4054efc

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 erc::ERC721Events;20use evm_coder::ToLog;21use frame_support::{22	BoundedVec, ensure, fail, transactional,23	storage::with_transaction,24	pallet_prelude::DispatchResultWithPostInfo,25	pallet_prelude::Weight,26	weights::{PostDispatchInfo, Pays},27};28use up_data_structs::{29	AccessMode, CollectionId, CustomDataLimit, TokenId, CreateCollectionData, CreateNftExData,30	mapping::TokenAddressMapping, budget::Budget, Property, PropertyPermission, PropertyKey,31	PropertyKeyPermission, Properties, PropertyScope, TrySetProperty, TokenChild, AuxPropertyValue,32};33use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};34use pallet_common::{35	Error as CommonError, Pallet as PalletCommon, Event as CommonEvent, CollectionHandle,36	eth::collection_id_to_address,37};38use pallet_structure::{Pallet as PalletStructure, Error as StructureError};39use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};40use sp_core::H160;41use sp_runtime::{ArithmeticError, DispatchError, DispatchResult, TransactionOutcome};42use sp_std::{vec::Vec, vec, collections::btree_map::BTreeMap, collections::btree_set::BTreeSet};43use core::ops::Deref;44use codec::{Encode, Decode, MaxEncodedLen};45use scale_info::TypeInfo;4647pub use pallet::*;48use weights::WeightInfo;49#[cfg(feature = "runtime-benchmarks")]50pub mod benchmarking;51pub mod common;52pub mod erc;53pub mod weights;5455pub type CreateItemData<T> = CreateNftExData<<T as pallet_evm::account::Config>::CrossAccountId>;56pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;5758#[struct_versioning::versioned(version = 2, upper)]59#[derive(Encode, Decode, TypeInfo, MaxEncodedLen)]60pub struct ItemData<CrossAccountId> {61	#[version(..2)]62	pub const_data: BoundedVec<u8, CustomDataLimit>,6364	#[version(..2)]65	pub variable_data: BoundedVec<u8, CustomDataLimit>,6667	pub owner: CrossAccountId,68}6970#[frame_support::pallet]71pub mod pallet {72	use super::*;73	use frame_support::{74		Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key, traits::StorageVersion,75	};76	use frame_system::pallet_prelude::*;77	use up_data_structs::{CollectionId, TokenId};78	use super::weights::WeightInfo;7980	#[pallet::error]81	pub enum Error<T> {82		/// Not Nonfungible item data used to mint in Nonfungible collection.83		NotNonfungibleDataUsedToMintFungibleCollectionToken,84		/// Used amount > 1 with NFT85		NonfungibleItemsHaveNoAmount,86		/// Unable to burn NFT with children87		CantBurnNftWithChildren,88	}8990	#[pallet::config]91	pub trait Config:92		frame_system::Config + pallet_common::Config + pallet_structure::Config + pallet_evm::Config93	{94		type WeightInfo: WeightInfo;95	}9697	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);9899	#[pallet::pallet]100	#[pallet::storage_version(STORAGE_VERSION)]101	#[pallet::generate_store(pub(super) trait Store)]102	pub struct Pallet<T>(_);103104	#[pallet::storage]105	pub type TokensMinted<T: Config> =106		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;107	#[pallet::storage]108	pub type TokensBurnt<T: Config> =109		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;110111	#[pallet::storage]112	pub type TokenData<T: Config> = StorageNMap<113		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),114		Value = ItemData<T::CrossAccountId>,115		QueryKind = OptionQuery,116	>;117118	#[pallet::storage]119	#[pallet::getter(fn token_properties)]120	pub type TokenProperties<T: Config> = StorageNMap<121		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),122		Value = Properties,123		QueryKind = ValueQuery,124		OnEmpty = up_data_structs::TokenProperties,125	>;126127	#[pallet::storage]128	#[pallet::getter(fn token_aux_property)]129	pub type TokenAuxProperties<T: Config> = StorageNMap<130		Key = (131			Key<Twox64Concat, CollectionId>,132			Key<Twox64Concat, TokenId>,133			Key<Twox64Concat, PropertyScope>,134			Key<Twox64Concat, PropertyKey>,135		),136		Value = AuxPropertyValue,137		QueryKind = OptionQuery,138	>;139140	/// Used to enumerate tokens owned by account141	#[pallet::storage]142	pub type Owned<T: Config> = StorageNMap<143		Key = (144			Key<Twox64Concat, CollectionId>,145			Key<Blake2_128Concat, T::CrossAccountId>,146			Key<Twox64Concat, TokenId>,147		),148		Value = bool,149		QueryKind = ValueQuery,150	>;151152	/// Used to enumerate token's children153	#[pallet::storage]154	#[pallet::getter(fn token_children)]155	pub type TokenChildren<T: Config> = StorageNMap<156		Key = (157			Key<Twox64Concat, CollectionId>,158			Key<Twox64Concat, TokenId>,159			Key<Twox64Concat, (CollectionId, TokenId)>,160		),161		Value = bool,162		QueryKind = ValueQuery,163	>;164165	#[pallet::storage]166	pub type AccountBalance<T: Config> = StorageNMap<167		Key = (168			Key<Twox64Concat, CollectionId>,169			Key<Blake2_128Concat, T::CrossAccountId>,170		),171		Value = u32,172		QueryKind = ValueQuery,173	>;174175	#[pallet::storage]176	pub type Allowance<T: Config> = StorageNMap<177		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),178		Value = T::CrossAccountId,179		QueryKind = OptionQuery,180	>;181182	#[pallet::hooks]183	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {184		fn on_runtime_upgrade() -> Weight {185			if StorageVersion::get::<Pallet<T>>() < StorageVersion::new(1) {186				let mut had_consts = BTreeSet::new();187				<TokenData<T>>::translate::<ItemDataVersion1<T::CrossAccountId>, _>(188					|(collection, token), v| {189						let mut props = vec![];190						if !v.const_data.is_empty() {191							props.push(Property {192								key: b"_old_constData".to_vec().try_into().unwrap(),193								value: v194									.const_data195									.clone()196									.into_inner()197									.try_into()198									.expect("const too long"),199							});200							had_consts.insert(collection);201						}202						if !v.variable_data.is_empty() {203							props.push(Property {204								key: b"_old_variableData".to_vec().try_into().unwrap(),205								value: v206									.variable_data207									.clone()208									.into_inner()209									.try_into()210									.expect("variable too long"),211							})212						}213						if !props.is_empty() {214							Self::set_scoped_token_properties(215								collection,216								token,217								PropertyScope::None,218								props.into_iter(),219							)220							.expect("existing token data exceeds property storage");221						}222						Some(<ItemDataVersion2<T::CrossAccountId>>::from(v))223					},224				);225				for collection in had_consts {226					<PalletCommon<T>>::set_property_permission_unchecked(227						collection,228						PropertyKeyPermission {229							key: b"_old_constData".to_vec().try_into().unwrap(),230							permission: PropertyPermission {231								mutable: false,232								collection_admin: true,233								token_owner: false,234							},235						},236					)237					.expect("failed to configure permission");238				}239			}240241			0242		}243	}244}245246pub struct NonfungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);247impl<T: Config> NonfungibleHandle<T> {248	pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {249		Self(inner)250	}251	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {252		self.0253	}254	pub fn common_mut(&mut self) -> &mut pallet_common::CollectionHandle<T> {255		&mut self.0256	}257}258impl<T: Config> WithRecorder<T> for NonfungibleHandle<T> {259	fn recorder(&self) -> &SubstrateRecorder<T> {260		self.0.recorder()261	}262	fn into_recorder(self) -> SubstrateRecorder<T> {263		self.0.into_recorder()264	}265}266impl<T: Config> Deref for NonfungibleHandle<T> {267	type Target = pallet_common::CollectionHandle<T>;268269	fn deref(&self) -> &Self::Target {270		&self.0271	}272}273274impl<T: Config> Pallet<T> {275	pub fn total_supply(collection: &NonfungibleHandle<T>) -> u32 {276		<TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)277	}278	pub fn token_exists(collection: &NonfungibleHandle<T>, token: TokenId) -> bool {279		<TokenData<T>>::contains_key((collection.id, token))280	}281282	pub fn set_scoped_token_property(283		collection_id: CollectionId,284		token_id: TokenId,285		scope: PropertyScope,286		property: Property,287	) -> DispatchResult {288		TokenProperties::<T>::try_mutate((collection_id, token_id), |properties| {289			properties.try_scoped_set(scope, property.key, property.value)290		})291		.map_err(<CommonError<T>>::from)?;292293		Ok(())294	}295296	pub fn set_scoped_token_properties(297		collection_id: CollectionId,298		token_id: TokenId,299		scope: PropertyScope,300		properties: impl Iterator<Item = Property>,301	) -> DispatchResult {302		TokenProperties::<T>::try_mutate((collection_id, token_id), |stored_properties| {303			stored_properties.try_scoped_set_from_iter(scope, properties)304		})305		.map_err(<CommonError<T>>::from)?;306307		Ok(())308	}309310	pub fn try_mutate_token_aux_property<R, E>(311		collection_id: CollectionId,312		token_id: TokenId,313		scope: PropertyScope,314		key: PropertyKey,315		f: impl FnOnce(&mut Option<AuxPropertyValue>) -> Result<R, E>,316	) -> Result<R, E> {317		<TokenAuxProperties<T>>::try_mutate((collection_id, token_id, scope, key), f)318	}319320	pub fn remove_token_aux_property(321		collection_id: CollectionId,322		token_id: TokenId,323		scope: PropertyScope,324		key: PropertyKey,325	) {326		<TokenAuxProperties<T>>::remove((collection_id, token_id, scope, key));327	}328329	pub fn iterate_token_aux_properties(330		collection_id: CollectionId,331		token_id: TokenId,332		scope: PropertyScope,333	) -> impl Iterator<Item = (PropertyKey, AuxPropertyValue)> {334		<TokenAuxProperties<T>>::iter_prefix((collection_id, token_id, scope))335	}336337	pub fn current_token_id(collection_id: CollectionId) -> TokenId {338		TokenId(<TokensMinted<T>>::get(collection_id))339	}340}341342// unchecked calls skips any permission checks343impl<T: Config> Pallet<T> {344	pub fn init_collection(345		owner: T::CrossAccountId,346		data: CreateCollectionData<T::AccountId>,347		is_external: bool,348	) -> Result<CollectionId, DispatchError> {349		<PalletCommon<T>>::init_collection(owner, data, is_external)350	}351	pub fn destroy_collection(352		collection: NonfungibleHandle<T>,353		sender: &T::CrossAccountId,354	) -> DispatchResult {355		let id = collection.id;356357		if Self::collection_has_tokens(id) {358			return Err(<CommonError<T>>::CantDestroyNotEmptyCollection.into());359		}360361		// =========362363		PalletCommon::destroy_collection(collection.0, sender)?;364365		<TokenData<T>>::remove_prefix((id,), None);366		<TokenChildren<T>>::remove_prefix((id,), None);367		<Owned<T>>::remove_prefix((id,), None);368		<TokensMinted<T>>::remove(id);369		<TokensBurnt<T>>::remove(id);370		<Allowance<T>>::remove_prefix((id,), None);371		<AccountBalance<T>>::remove_prefix((id,), None);372		Ok(())373	}374375	pub fn burn(376		collection: &NonfungibleHandle<T>,377		sender: &T::CrossAccountId,378		token: TokenId,379	) -> DispatchResult {380		let token_data =381			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;382		ensure!(383			&token_data.owner == sender384				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(sender)),385			<CommonError<T>>::NoPermission386		);387388		if collection.permissions.access() == AccessMode::AllowList {389			collection.check_allowlist(sender)?;390		}391392		if Self::token_has_children(collection.id, token) {393			return Err(<Error<T>>::CantBurnNftWithChildren.into());394		}395396		let burnt = <TokensBurnt<T>>::get(collection.id)397			.checked_add(1)398			.ok_or(ArithmeticError::Overflow)?;399400		let balance = <AccountBalance<T>>::get((collection.id, token_data.owner.clone()))401			.checked_sub(1)402			.ok_or(ArithmeticError::Overflow)?;403404		// =========405406		if balance == 0 {407			<AccountBalance<T>>::remove((collection.id, token_data.owner.clone()));408		} else {409			<AccountBalance<T>>::insert((collection.id, token_data.owner.clone()), balance);410		}411412		<PalletStructure<T>>::unnest_if_nested(&token_data.owner, collection.id, token);413414		<Owned<T>>::remove((collection.id, &token_data.owner, token));415		<TokensBurnt<T>>::insert(collection.id, burnt);416		<TokenData<T>>::remove((collection.id, token));417		<TokenProperties<T>>::remove((collection.id, token));418		<TokenAuxProperties<T>>::remove_prefix((collection.id, token), None);419		let old_spender = <Allowance<T>>::take((collection.id, token));420421		if let Some(old_spender) = old_spender {422			<PalletCommon<T>>::deposit_event(CommonEvent::Approved(423				collection.id,424				token,425				token_data.owner.clone(),426				old_spender,427				0,428			));429		}430431		<PalletEvm<T>>::deposit_log(432			ERC721Events::Transfer {433				from: *token_data.owner.as_eth(),434				to: H160::default(),435				token_id: token.into(),436			}437			.to_log(collection_id_to_address(collection.id)),438		);439		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(440			collection.id,441			token,442			token_data.owner,443			1,444		));445		Ok(())446	}447448	#[transactional]449	pub fn burn_recursively(450		collection: &NonfungibleHandle<T>,451		sender: &T::CrossAccountId,452		token: TokenId,453		self_budget: &dyn Budget,454		breadth_budget: &dyn Budget,455	) -> DispatchResultWithPostInfo {456		ensure!(self_budget.consume(), <StructureError<T>>::DepthLimit,);457458		let current_token_account =459			T::CrossTokenAddressMapping::token_to_address(collection.id, token);460461		let mut weight = 0 as Weight;462463		// This method is transactional, if user in fact doesn't have permissions to remove token -464		// tokens removed here will be restored after rejected transaction465		for ((collection, token), _) in <TokenChildren<T>>::iter_prefix((collection.id, token)) {466			ensure!(breadth_budget.consume(), <StructureError<T>>::BreadthLimit,);467			let PostDispatchInfo { actual_weight, .. } =468				<PalletStructure<T>>::burn_item_recursively(469					current_token_account.clone(),470					collection,471					token,472					self_budget,473					breadth_budget,474				)?;475			if let Some(actual_weight) = actual_weight {476				weight = weight.saturating_add(actual_weight);477			}478		}479480		Self::burn(collection, sender, token)?;481		DispatchResultWithPostInfo::Ok(PostDispatchInfo {482			actual_weight: Some(weight + <SelfWeightOf<T>>::burn_item()),483			pays_fee: Pays::Yes,484		})485	}486487	pub fn set_token_property(488		collection: &NonfungibleHandle<T>,489		sender: &T::CrossAccountId,490		token_id: TokenId,491		property: Property,492		is_token_create: bool,493	) -> DispatchResult {494		Self::check_token_change_permission(495			collection,496			sender,497			token_id,498			&property.key,499			is_token_create,500		)?;501502		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {503			let property = property.clone();504			properties.try_set(property.key, property.value)505		})506		.map_err(<CommonError<T>>::from)?;507508		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertySet(509			collection.id,510			token_id,511			property.key,512		));513514		Ok(())515	}516517	#[transactional]518	pub fn set_token_properties(519		collection: &NonfungibleHandle<T>,520		sender: &T::CrossAccountId,521		token_id: TokenId,522		properties: Vec<Property>,523		is_token_create: bool,524	) -> DispatchResult {525		for property in properties {526			Self::set_token_property(collection, sender, token_id, property, is_token_create)?;527		}528529		Ok(())530	}531532	pub fn delete_token_property(533		collection: &NonfungibleHandle<T>,534		sender: &T::CrossAccountId,535		token_id: TokenId,536		property_key: PropertyKey,537	) -> DispatchResult {538		Self::check_token_change_permission(collection, sender, token_id, &property_key, false)?;539540		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {541			properties.remove(&property_key)542		})543		.map_err(<CommonError<T>>::from)?;544545		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertyDeleted(546			collection.id,547			token_id,548			property_key,549		));550551		Ok(())552	}553554	fn check_token_change_permission(555		collection: &NonfungibleHandle<T>,556		sender: &T::CrossAccountId,557		token_id: TokenId,558		property_key: &PropertyKey,559		is_token_create: bool,560	) -> DispatchResult {561		let permission = <PalletCommon<T>>::property_permissions(collection.id)562			.get(property_key)563			.cloned()564			.unwrap_or_else(PropertyPermission::none);565566		let token_data = <TokenData<T>>::get((collection.id, token_id))567			.ok_or(<CommonError<T>>::TokenNotFound)?;568569		let check_token_owner = || -> DispatchResult {570			ensure!(&token_data.owner == sender, <CommonError<T>>::NoPermission);571			Ok(())572		};573574		let is_property_exists = TokenProperties::<T>::get((collection.id, token_id))575			.get(property_key)576			.is_some();577578		match permission {579			PropertyPermission { mutable: false, .. } if is_property_exists => {580				Err(<CommonError<T>>::NoPermission.into())581			}582583			PropertyPermission {584				collection_admin,585				token_owner,586				..587			} => {588				//TODO: investigate threats during public minting.589				if is_token_create && (collection_admin || token_owner) {590					return Ok(());591				}592593				let mut check_result = Err(<CommonError<T>>::NoPermission.into());594595				if collection_admin {596					check_result = collection.check_is_owner_or_admin(sender);597				}598599				if token_owner {600					check_result.or_else(|_| check_token_owner())601				} else {602					check_result603				}604			}605		}606	}607608	#[transactional]609	pub fn delete_token_properties(610		collection: &NonfungibleHandle<T>,611		sender: &T::CrossAccountId,612		token_id: TokenId,613		property_keys: Vec<PropertyKey>,614	) -> DispatchResult {615		for key in property_keys {616			Self::delete_token_property(collection, sender, token_id, key)?;617		}618619		Ok(())620	}621622	pub fn set_collection_properties(623		collection: &NonfungibleHandle<T>,624		sender: &T::CrossAccountId,625		properties: Vec<Property>,626	) -> DispatchResult {627		<PalletCommon<T>>::set_collection_properties(collection, sender, properties)628	}629630	pub fn delete_collection_properties(631		collection: &CollectionHandle<T>,632		sender: &T::CrossAccountId,633		property_keys: Vec<PropertyKey>,634	) -> DispatchResult {635		<PalletCommon<T>>::delete_collection_properties(collection, sender, property_keys)636	}637638	pub fn set_token_property_permissions(639		collection: &CollectionHandle<T>,640		sender: &T::CrossAccountId,641		property_permissions: Vec<PropertyKeyPermission>,642	) -> DispatchResult {643		<PalletCommon<T>>::set_token_property_permissions(collection, sender, property_permissions)644	}645646	pub fn set_property_permission(647		collection: &CollectionHandle<T>,648		sender: &T::CrossAccountId,649		permission: PropertyKeyPermission,650	) -> DispatchResult {651		<PalletCommon<T>>::set_property_permission(collection, sender, permission)652	}653654	pub fn transfer(655		collection: &NonfungibleHandle<T>,656		from: &T::CrossAccountId,657		to: &T::CrossAccountId,658		token: TokenId,659		nesting_budget: &dyn Budget,660	) -> DispatchResult {661		ensure!(662			collection.limits.transfers_enabled(),663			<CommonError<T>>::TransferNotAllowed664		);665666		let token_data =667			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;668		// TODO: require sender to be token, owner, require admins to go through transfer_from669		ensure!(670			&token_data.owner == from671				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(from)),672			<CommonError<T>>::NoPermission673		);674675		if collection.permissions.access() == AccessMode::AllowList {676			collection.check_allowlist(from)?;677			collection.check_allowlist(to)?;678		}679		<PalletCommon<T>>::ensure_correct_receiver(to)?;680681		let balance_from = <AccountBalance<T>>::get((collection.id, from))682			.checked_sub(1)683			.ok_or(<CommonError<T>>::TokenValueTooLow)?;684		let balance_to = if from != to {685			let balance_to = <AccountBalance<T>>::get((collection.id, to))686				.checked_add(1)687				.ok_or(ArithmeticError::Overflow)?;688689			ensure!(690				balance_to < collection.limits.account_token_ownership_limit(),691				<CommonError<T>>::AccountTokenLimitExceeded,692			);693694			Some(balance_to)695		} else {696			None697		};698699		<PalletStructure<T>>::nest_if_sent_to_token(700			from.clone(),701			to,702			collection.id,703			token,704			nesting_budget,705		)?;706707		// =========708709		<PalletStructure<T>>::unnest_if_nested(&token_data.owner, collection.id, token);710711		<TokenData<T>>::insert(712			(collection.id, token),713			ItemData {714				owner: to.clone(),715				..token_data716			},717		);718719		if let Some(balance_to) = balance_to {720			// from != to721			if balance_from == 0 {722				<AccountBalance<T>>::remove((collection.id, from));723			} else {724				<AccountBalance<T>>::insert((collection.id, from), balance_from);725			}726			<AccountBalance<T>>::insert((collection.id, to), balance_to);727			<Owned<T>>::remove((collection.id, from, token));728			<Owned<T>>::insert((collection.id, to, token), true);729		}730		Self::set_allowance_unchecked(collection, from, token, None, true);731732		<PalletEvm<T>>::deposit_log(733			ERC721Events::Transfer {734				from: *from.as_eth(),735				to: *to.as_eth(),736				token_id: token.into(),737			}738			.to_log(collection_id_to_address(collection.id)),739		);740		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(741			collection.id,742			token,743			from.clone(),744			to.clone(),745			1,746		));747		Ok(())748	}749750	pub fn create_multiple_items(751		collection: &NonfungibleHandle<T>,752		sender: &T::CrossAccountId,753		data: Vec<CreateItemData<T>>,754		nesting_budget: &dyn Budget,755	) -> DispatchResult {756		if !collection.is_owner_or_admin(sender) {757			ensure!(758				collection.permissions.mint_mode(),759				<CommonError<T>>::PublicMintingNotAllowed760			);761			collection.check_allowlist(sender)?;762763			for item in data.iter() {764				collection.check_allowlist(&item.owner)?;765			}766		}767768		for data in data.iter() {769			<PalletCommon<T>>::ensure_correct_receiver(&data.owner)?;770		}771772		let first_token = <TokensMinted<T>>::get(collection.id);773		let tokens_minted = first_token774			.checked_add(data.len() as u32)775			.ok_or(ArithmeticError::Overflow)?;776		ensure!(777			tokens_minted <= collection.limits.token_limit(),778			<CommonError<T>>::CollectionTokenLimitExceeded779		);780781		let mut balances = BTreeMap::new();782		for data in &data {783			let balance = balances784				.entry(&data.owner)785				.or_insert_with(|| <AccountBalance<T>>::get((collection.id, &data.owner)));786			*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;787788			ensure!(789				*balance <= collection.limits.account_token_ownership_limit(),790				<CommonError<T>>::AccountTokenLimitExceeded,791			);792		}793794		for (i, data) in data.iter().enumerate() {795			let token = TokenId(first_token + i as u32 + 1);796797			<PalletStructure<T>>::check_nesting(798				sender.clone(),799				&data.owner,800				collection.id,801				token,802				nesting_budget,803			)?;804		}805806		// =========807808		with_transaction(|| {809			for (i, data) in data.iter().enumerate() {810				let token = first_token + i as u32 + 1;811812				<TokenData<T>>::insert(813					(collection.id, token),814					ItemData {815						// const_data: data.const_data.clone(),816						owner: data.owner.clone(),817					},818				);819820				<PalletStructure<T>>::nest_if_sent_to_token_unchecked(821					&data.owner,822					collection.id,823					TokenId(token),824				);825826				if let Err(e) = Self::set_token_properties(827					collection,828					sender,829					TokenId(token),830					data.properties.clone().into_inner(),831					true,832				) {833					return TransactionOutcome::Rollback(Err(e));834				}835			}836			TransactionOutcome::Commit(Ok(()))837		})?;838839		<TokensMinted<T>>::insert(collection.id, tokens_minted);840		for (account, balance) in balances {841			<AccountBalance<T>>::insert((collection.id, account), balance);842		}843		for (i, data) in data.into_iter().enumerate() {844			let token = first_token + i as u32 + 1;845			<Owned<T>>::insert((collection.id, &data.owner, token), true);846847			<PalletEvm<T>>::deposit_log(848				ERC721Events::Transfer {849					from: H160::default(),850					to: *data.owner.as_eth(),851					token_id: token.into(),852				}853				.to_log(collection_id_to_address(collection.id)),854			);855			<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(856				collection.id,857				TokenId(token),858				data.owner.clone(),859				1,860			));861		}862		Ok(())863	}864865	pub fn set_allowance_unchecked(866		collection: &NonfungibleHandle<T>,867		sender: &T::CrossAccountId,868		token: TokenId,869		spender: Option<&T::CrossAccountId>,870		assume_implicit_eth: bool,871	) {872		if let Some(spender) = spender {873			let old_spender = <Allowance<T>>::get((collection.id, token));874			<Allowance<T>>::insert((collection.id, token), spender);875			// In ERC721 there is only one possible approved user of token, so we set876			// approved user to spender877			<PalletEvm<T>>::deposit_log(878				ERC721Events::Approval {879					owner: *sender.as_eth(),880					approved: *spender.as_eth(),881					token_id: token.into(),882				}883				.to_log(collection_id_to_address(collection.id)),884			);885			// In Unique chain, any token can have any amount of approved users, so we need to886			// set allowance of old owner to 0, and allowance of new owner to 1887			if old_spender.as_ref() != Some(spender) {888				if let Some(old_owner) = old_spender {889					<PalletCommon<T>>::deposit_event(CommonEvent::Approved(890						collection.id,891						token,892						sender.clone(),893						old_owner,894						0,895					));896				}897				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(898					collection.id,899					token,900					sender.clone(),901					spender.clone(),902					1,903				));904			}905		} else {906			let old_spender = <Allowance<T>>::take((collection.id, token));907			if !assume_implicit_eth {908				// In ERC721 there is only one possible approved user of token, so we set909				// approved user to zero address910				<PalletEvm<T>>::deposit_log(911					ERC721Events::Approval {912						owner: *sender.as_eth(),913						approved: H160::default(),914						token_id: token.into(),915					}916					.to_log(collection_id_to_address(collection.id)),917				);918			}919			// In Unique chain, any token can have any amount of approved users, so we need to920			// set allowance of old owner to 0921			if let Some(old_spender) = old_spender {922				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(923					collection.id,924					token,925					sender.clone(),926					old_spender,927					0,928				));929			}930		}931	}932933	pub fn set_allowance(934		collection: &NonfungibleHandle<T>,935		sender: &T::CrossAccountId,936		token: TokenId,937		spender: Option<&T::CrossAccountId>,938	) -> DispatchResult {939		if collection.permissions.access() == AccessMode::AllowList {940			collection.check_allowlist(sender)?;941			if let Some(spender) = spender {942				collection.check_allowlist(spender)?;943			}944		}945946		if let Some(spender) = spender {947			<PalletCommon<T>>::ensure_correct_receiver(spender)?;948		}949950		let token_data =951			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;952		if &token_data.owner != sender {953			ensure!(954				collection.ignores_owned_amount(sender),955				<CommonError<T>>::CantApproveMoreThanOwned956			);957		}958959		// =========960961		Self::set_allowance_unchecked(collection, sender, token, spender, false);962		Ok(())963	}964965	fn check_allowed(966		collection: &NonfungibleHandle<T>,967		spender: &T::CrossAccountId,968		from: &T::CrossAccountId,969		token: TokenId,970		nesting_budget: &dyn Budget,971	) -> DispatchResult {972		if spender.conv_eq(from) {973			return Ok(());974		}975		if collection.permissions.access() == AccessMode::AllowList {976			// `from`, `to` checked in [`transfer`]977			collection.check_allowlist(spender)?;978		}979		if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {980			// TODO: should collection owner be allowed to perform this transfer?981			ensure!(982				<PalletStructure<T>>::check_indirectly_owned(983					spender.clone(),984					source.0,985					source.1,986					None,987					nesting_budget988				)?,989				<CommonError<T>>::ApprovedValueTooLow,990			);991			return Ok(());992		}993		if <Allowance<T>>::get((collection.id, token)).as_ref() == Some(spender) {994			return Ok(());995		}996		ensure!(997			collection.ignores_allowance(spender),998			<CommonError<T>>::ApprovedValueTooLow999		);1000		Ok(())1001	}10021003	pub fn transfer_from(1004		collection: &NonfungibleHandle<T>,1005		spender: &T::CrossAccountId,1006		from: &T::CrossAccountId,1007		to: &T::CrossAccountId,1008		token: TokenId,1009		nesting_budget: &dyn Budget,1010	) -> DispatchResult {1011		Self::check_allowed(collection, spender, from, token, nesting_budget)?;10121013		// =========10141015		// Allowance is reset in [`transfer`]1016		Self::transfer(collection, from, to, token, nesting_budget)1017	}10181019	pub fn burn_from(1020		collection: &NonfungibleHandle<T>,1021		spender: &T::CrossAccountId,1022		from: &T::CrossAccountId,1023		token: TokenId,1024		nesting_budget: &dyn Budget,1025	) -> DispatchResult {1026		Self::check_allowed(collection, spender, from, token, nesting_budget)?;10271028		// =========10291030		Self::burn(collection, from, token)1031	}10321033	pub fn check_nesting(1034		handle: &NonfungibleHandle<T>,1035		sender: T::CrossAccountId,1036		from: (CollectionId, TokenId),1037		under: TokenId,1038		nesting_budget: &dyn Budget,1039	) -> DispatchResult {1040		let nesting = handle.permissions.nesting();10411042		#[cfg(not(feature = "runtime-benchmarks"))]1043		let permissive = false;1044		#[cfg(feature = "runtime-benchmarks")]1045		let permissive = nesting.permissive;10461047		if permissive {1048			// Pass1049		} else if nesting.token_owner1050			&& <PalletStructure<T>>::check_indirectly_owned(1051				sender.clone(),1052				handle.id,1053				under,1054				Some(from),1055				nesting_budget,1056			)? {1057			// Pass1058		} else if nesting.collection_admin && handle.is_owner_or_admin(&sender) {1059			// Pass1060		} else {1061			fail!(<CommonError<T>>::UserIsNotAllowedToNest);1062		}10631064		if let Some(whitelist) = &nesting.restricted {1065			ensure!(1066				whitelist.contains(&from.0),1067				<CommonError<T>>::SourceCollectionIsNotAllowedToNest1068			);1069		}1070		Ok(())1071	}10721073	fn nest(under: (CollectionId, TokenId), to_nest: (CollectionId, TokenId)) {1074		<TokenChildren<T>>::insert((under.0, under.1, (to_nest.0, to_nest.1)), true);1075	}10761077	fn unnest(under: (CollectionId, TokenId), to_unnest: (CollectionId, TokenId)) {1078		<TokenChildren<T>>::remove((under.0, under.1, to_unnest));1079	}10801081	fn collection_has_tokens(collection_id: CollectionId) -> bool {1082		<TokenData<T>>::iter_prefix((collection_id,))1083			.next()1084			.is_some()1085	}10861087	fn token_has_children(collection_id: CollectionId, token_id: TokenId) -> bool {1088		<TokenChildren<T>>::iter_prefix((collection_id, token_id))1089			.next()1090			.is_some()1091	}10921093	pub fn token_children_ids(collection_id: CollectionId, token_id: TokenId) -> Vec<TokenChild> {1094		<TokenChildren<T>>::iter_prefix((collection_id, token_id))1095			.map(|((child_collection_id, child_id), _)| TokenChild {1096				collection: child_collection_id,1097				token: child_id,1098			})1099			.collect()1100	}11011102	/// Delegated to `create_multiple_items`1103	pub fn create_item(1104		collection: &NonfungibleHandle<T>,1105		sender: &T::CrossAccountId,1106		data: CreateItemData<T>,1107		nesting_budget: &dyn Budget,1108	) -> DispatchResult {1109		Self::create_multiple_items(collection, sender, vec![data], nesting_budget)1110	}1111}