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

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;5455mod property_guard;5657use property_guard::*;5859pub type CreateItemData<T> = CreateNftExData<<T as pallet_evm::account::Config>::CrossAccountId>;60pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;6162#[struct_versioning::versioned(version = 2, upper)]63#[derive(Encode, Decode, TypeInfo, MaxEncodedLen)]64pub struct ItemData<CrossAccountId> {65	#[version(..2)]66	pub const_data: BoundedVec<u8, CustomDataLimit>,6768	#[version(..2)]69	pub variable_data: BoundedVec<u8, CustomDataLimit>,7071	pub owner: CrossAccountId,72}7374#[frame_support::pallet]75pub mod pallet {76	use super::*;77	use frame_support::{78		Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key, traits::StorageVersion,79	};80	use frame_system::pallet_prelude::*;81	use up_data_structs::{CollectionId, TokenId};82	use super::weights::WeightInfo;8384	#[pallet::error]85	pub enum Error<T> {86		/// Not Nonfungible item data used to mint in Nonfungible collection.87		NotNonfungibleDataUsedToMintFungibleCollectionToken,88		/// Used amount > 1 with NFT89		NonfungibleItemsHaveNoAmount,90		/// Unable to burn NFT with children91		CantBurnNftWithChildren,92	}9394	#[pallet::config]95	pub trait Config:96		frame_system::Config + pallet_common::Config + pallet_structure::Config + pallet_evm::Config97	{98		type WeightInfo: WeightInfo;99	}100101	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);102103	#[pallet::pallet]104	#[pallet::storage_version(STORAGE_VERSION)]105	#[pallet::generate_store(pub(super) trait Store)]106	pub struct Pallet<T>(_);107108	#[pallet::storage]109	pub type TokensMinted<T: Config> =110		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;111	#[pallet::storage]112	pub type TokensBurnt<T: Config> =113		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;114115	#[pallet::storage]116	pub type TokenData<T: Config> = StorageNMap<117		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),118		Value = ItemData<T::CrossAccountId>,119		QueryKind = OptionQuery,120	>;121122	#[pallet::storage]123	#[pallet::getter(fn token_properties)]124	pub type TokenProperties<T: Config> = StorageNMap<125		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),126		Value = Properties,127		QueryKind = ValueQuery,128		OnEmpty = up_data_structs::TokenProperties,129	>;130131	#[pallet::storage]132	#[pallet::getter(fn token_aux_property)]133	pub type TokenAuxProperties<T: Config> = StorageNMap<134		Key = (135			Key<Twox64Concat, CollectionId>,136			Key<Twox64Concat, TokenId>,137			Key<Twox64Concat, PropertyScope>,138			Key<Twox64Concat, PropertyKey>,139		),140		Value = AuxPropertyValue,141		QueryKind = OptionQuery,142	>;143144	/// Used to enumerate tokens owned by account145	#[pallet::storage]146	pub type Owned<T: Config> = StorageNMap<147		Key = (148			Key<Twox64Concat, CollectionId>,149			Key<Blake2_128Concat, T::CrossAccountId>,150			Key<Twox64Concat, TokenId>,151		),152		Value = bool,153		QueryKind = ValueQuery,154	>;155156	/// Used to enumerate token's children157	#[pallet::storage]158	#[pallet::getter(fn token_children)]159	pub type TokenChildren<T: Config> = StorageNMap<160		Key = (161			Key<Twox64Concat, CollectionId>,162			Key<Twox64Concat, TokenId>,163			Key<Twox64Concat, (CollectionId, TokenId)>,164		),165		Value = bool,166		QueryKind = ValueQuery,167	>;168169	#[pallet::storage]170	pub type AccountBalance<T: Config> = StorageNMap<171		Key = (172			Key<Twox64Concat, CollectionId>,173			Key<Blake2_128Concat, T::CrossAccountId>,174		),175		Value = u32,176		QueryKind = ValueQuery,177	>;178179	#[pallet::storage]180	pub type Allowance<T: Config> = StorageNMap<181		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),182		Value = T::CrossAccountId,183		QueryKind = OptionQuery,184	>;185186	#[pallet::hooks]187	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {188		fn on_runtime_upgrade() -> Weight {189			if StorageVersion::get::<Pallet<T>>() < StorageVersion::new(1) {190				let mut had_consts = BTreeSet::new();191				<TokenData<T>>::translate::<ItemDataVersion1<T::CrossAccountId>, _>(192					|(collection, token), v| {193						let mut props = vec![];194						if !v.const_data.is_empty() {195							props.push(Property {196								key: b"_old_constData".to_vec().try_into().unwrap(),197								value: v198									.const_data199									.clone()200									.into_inner()201									.try_into()202									.expect("const too long"),203							});204							had_consts.insert(collection);205						}206						if !v.variable_data.is_empty() {207							props.push(Property {208								key: b"_old_variableData".to_vec().try_into().unwrap(),209								value: v210									.variable_data211									.clone()212									.into_inner()213									.try_into()214									.expect("variable too long"),215							})216						}217						if !props.is_empty() {218							Self::set_scoped_token_properties(219								collection,220								token,221								PropertyScope::None,222								props.into_iter(),223							)224							.expect("existing token data exceeds property storage");225						}226						Some(<ItemDataVersion2<T::CrossAccountId>>::from(v))227					},228				);229				for collection in had_consts {230					<PalletCommon<T>>::set_property_permission_unchecked(231						collection,232						PropertyKeyPermission {233							key: b"_old_constData".to_vec().try_into().unwrap(),234							permission: PropertyPermission {235								mutable: false,236								collection_admin: true,237								token_owner: false,238							},239						},240					)241					.expect("failed to configure permission");242				}243			}244245			0246		}247	}248}249250pub struct NonfungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);251impl<T: Config> NonfungibleHandle<T> {252	pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {253		Self(inner)254	}255	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {256		self.0257	}258	pub fn common_mut(&mut self) -> &mut pallet_common::CollectionHandle<T> {259		&mut self.0260	}261}262impl<T: Config> WithRecorder<T> for NonfungibleHandle<T> {263	fn recorder(&self) -> &SubstrateRecorder<T> {264		self.0.recorder()265	}266	fn into_recorder(self) -> SubstrateRecorder<T> {267		self.0.into_recorder()268	}269}270impl<T: Config> Deref for NonfungibleHandle<T> {271	type Target = pallet_common::CollectionHandle<T>;272273	fn deref(&self) -> &Self::Target {274		&self.0275	}276}277278impl<T: Config> Pallet<T> {279	pub fn total_supply(collection: &NonfungibleHandle<T>) -> u32 {280		<TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)281	}282	pub fn token_exists(collection: &NonfungibleHandle<T>, token: TokenId) -> bool {283		<TokenData<T>>::contains_key((collection.id, token))284	}285286	pub fn set_scoped_token_property(287		collection_id: CollectionId,288		token_id: TokenId,289		scope: PropertyScope,290		property: Property,291	) -> DispatchResult {292		TokenProperties::<T>::try_mutate((collection_id, token_id), |properties| {293			properties.try_scoped_set(scope, property.key, property.value)294		})295		.map_err(<CommonError<T>>::from)?;296297		Ok(())298	}299300	pub fn set_scoped_token_properties(301		collection_id: CollectionId,302		token_id: TokenId,303		scope: PropertyScope,304		properties: impl Iterator<Item = Property>,305	) -> DispatchResult {306		TokenProperties::<T>::try_mutate((collection_id, token_id), |stored_properties| {307			stored_properties.try_scoped_set_from_iter(scope, properties)308		})309		.map_err(<CommonError<T>>::from)?;310311		Ok(())312	}313314	pub fn try_mutate_token_aux_property<R, E>(315		collection_id: CollectionId,316		token_id: TokenId,317		scope: PropertyScope,318		key: PropertyKey,319		f: impl FnOnce(&mut Option<AuxPropertyValue>) -> Result<R, E>,320	) -> Result<R, E> {321		<TokenAuxProperties<T>>::try_mutate((collection_id, token_id, scope, key), f)322	}323324	pub fn remove_token_aux_property(325		collection_id: CollectionId,326		token_id: TokenId,327		scope: PropertyScope,328		key: PropertyKey,329	) {330		<TokenAuxProperties<T>>::remove((collection_id, token_id, scope, key));331	}332333	pub fn iterate_token_aux_properties(334		collection_id: CollectionId,335		token_id: TokenId,336		scope: PropertyScope,337	) -> impl Iterator<Item = (PropertyKey, AuxPropertyValue)> {338		<TokenAuxProperties<T>>::iter_prefix((collection_id, token_id, scope))339	}340341	pub fn current_token_id(collection_id: CollectionId) -> TokenId {342		TokenId(<TokensMinted<T>>::get(collection_id))343	}344}345346// unchecked calls skips any permission checks347impl<T: Config> Pallet<T> {348	pub fn init_collection(349		owner: T::CrossAccountId,350		data: CreateCollectionData<T::AccountId>,351		is_external: bool,352	) -> Result<CollectionId, DispatchError> {353		<PalletCommon<T>>::init_collection(owner, data, is_external)354	}355	pub fn destroy_collection(356		collection: NonfungibleHandle<T>,357		sender: &T::CrossAccountId,358	) -> DispatchResult {359		let id = collection.id;360361		if Self::collection_has_tokens(id) {362			return Err(<CommonError<T>>::CantDestroyNotEmptyCollection.into());363		}364365		// =========366367		PalletCommon::destroy_collection(collection.0, sender)?;368369		<TokenData<T>>::remove_prefix((id,), None);370		<TokenChildren<T>>::remove_prefix((id,), None);371		<Owned<T>>::remove_prefix((id,), None);372		<TokensMinted<T>>::remove(id);373		<TokensBurnt<T>>::remove(id);374		<Allowance<T>>::remove_prefix((id,), None);375		<AccountBalance<T>>::remove_prefix((id,), None);376		Ok(())377	}378379	pub fn burn(380		collection: &NonfungibleHandle<T>,381		sender: &T::CrossAccountId,382		token: TokenId,383	) -> DispatchResult {384		let token_data =385			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;386		ensure!(387			&token_data.owner == sender388				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(sender)),389			<CommonError<T>>::NoPermission390		);391392		if collection.permissions.access() == AccessMode::AllowList {393			collection.check_allowlist(sender)?;394		}395396		if Self::token_has_children(collection.id, token) {397			return Err(<Error<T>>::CantBurnNftWithChildren.into());398		}399400		let burnt = <TokensBurnt<T>>::get(collection.id)401			.checked_add(1)402			.ok_or(ArithmeticError::Overflow)?;403404		let balance = <AccountBalance<T>>::get((collection.id, token_data.owner.clone()))405			.checked_sub(1)406			.ok_or(ArithmeticError::Overflow)?;407408		// =========409410		if balance == 0 {411			<AccountBalance<T>>::remove((collection.id, token_data.owner.clone()));412		} else {413			<AccountBalance<T>>::insert((collection.id, token_data.owner.clone()), balance);414		}415416		<PalletStructure<T>>::unnest_if_nested(&token_data.owner, collection.id, token);417418		<Owned<T>>::remove((collection.id, &token_data.owner, token));419		<TokensBurnt<T>>::insert(collection.id, burnt);420		<TokenData<T>>::remove((collection.id, token));421		<TokenProperties<T>>::remove((collection.id, token));422		<TokenAuxProperties<T>>::remove_prefix((collection.id, token), None);423		let old_spender = <Allowance<T>>::take((collection.id, token));424425		if let Some(old_spender) = old_spender {426			<PalletCommon<T>>::deposit_event(CommonEvent::Approved(427				collection.id,428				token,429				token_data.owner.clone(),430				old_spender,431				0,432			));433		}434435		<PalletEvm<T>>::deposit_log(436			ERC721Events::Transfer {437				from: *token_data.owner.as_eth(),438				to: H160::default(),439				token_id: token.into(),440			}441			.to_log(collection_id_to_address(collection.id)),442		);443		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(444			collection.id,445			token,446			token_data.owner,447			1,448		));449		Ok(())450	}451452	#[transactional]453	pub fn burn_recursively(454		collection: &NonfungibleHandle<T>,455		sender: &T::CrossAccountId,456		token: TokenId,457		self_budget: &dyn Budget,458		breadth_budget: &dyn Budget,459	) -> DispatchResultWithPostInfo {460		ensure!(self_budget.consume(), <StructureError<T>>::DepthLimit,);461462		let current_token_account =463			T::CrossTokenAddressMapping::token_to_address(collection.id, token);464465		let mut weight = 0 as Weight;466467		// This method is transactional, if user in fact doesn't have permissions to remove token -468		// tokens removed here will be restored after rejected transaction469		for ((collection, token), _) in <TokenChildren<T>>::iter_prefix((collection.id, token)) {470			ensure!(breadth_budget.consume(), <StructureError<T>>::BreadthLimit,);471			let PostDispatchInfo { actual_weight, .. } =472				<PalletStructure<T>>::burn_item_recursively(473					current_token_account.clone(),474					collection,475					token,476					self_budget,477					breadth_budget,478				)?;479			if let Some(actual_weight) = actual_weight {480				weight = weight.saturating_add(actual_weight);481			}482		}483484		Self::burn(collection, sender, token)?;485		DispatchResultWithPostInfo::Ok(PostDispatchInfo {486			actual_weight: Some(weight + <SelfWeightOf<T>>::burn_item()),487			pays_fee: Pays::Yes,488		})489	}490491	pub fn set_token_property(492		property: Property,493		guard: &mut PropertyGuard<'_, T>,494	) -> DispatchResult {495		Self::check_token_change_permission(&property.key, guard)?;496497		<TokenProperties<T>>::try_mutate((guard.collection.id, guard.token_id), |properties| {498			let property = property.clone();499			properties.try_set(property.key, property.value)500		})501		.map_err(<CommonError<T>>::from)?;502503		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertySet(504			guard.collection.id,505			guard.token_id,506			property.key,507		));508509		Ok(())510	}511512	#[transactional]513	pub fn set_token_properties(514		collection: &NonfungibleHandle<T>,515		sender: &T::CrossAccountId,516		token_id: TokenId,517		properties: Vec<Property>,518		is_token_create: bool,519		nesting_budget: &dyn Budget,520	) -> DispatchResult {521		let mut guard = PropertyGuard::new(PropertyGuardData {522			sender,523			collection,524			token_id,525			is_token_create,526			nesting_budget,527		});528529		for property in properties {530			Self::set_token_property(property, &mut guard)?;531		}532533		Ok(())534	}535536	pub fn delete_token_property(537		property_key: PropertyKey,538		guard: &mut PropertyGuard<'_, T>,539	) -> DispatchResult {540		Self::check_token_change_permission(&property_key, guard)?;541542		<TokenProperties<T>>::try_mutate((guard.collection.id, guard.token_id), |properties| {543			properties.remove(&property_key)544		})545		.map_err(<CommonError<T>>::from)?;546547		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertyDeleted(548			guard.collection.id,549			guard.token_id,550			property_key,551		));552553		Ok(())554	}555556	fn check_token_change_permission(557		property_key: &PropertyKey,558		guard: &mut PropertyGuard<'_, T>,559	) -> DispatchResult {560		let permission = <PalletCommon<T>>::property_permissions(guard.collection.id)561			.get(property_key)562			.cloned()563			.unwrap_or_else(PropertyPermission::none);564565		let is_property_exists = TokenProperties::<T>::get((guard.collection.id, guard.token_id))566			.get(property_key)567			.is_some();568569		match permission {570			PropertyPermission { mutable: false, .. } if is_property_exists => {571				Err(<CommonError<T>>::NoPermission.into())572			}573574			PropertyPermission {575				collection_admin,576				token_owner,577				..578			} => {579				//TODO: investigate threats during public minting.580				if guard.is_token_create && (collection_admin || token_owner) {581					return Ok(());582				}583584				let mut check_result = Err(<CommonError<T>>::NoPermission.into());585586				if collection_admin {587					check_result = guard.check_collection_admin();588				}589590				if token_owner {591					check_result.or_else(|_| guard.check_token_owner())592				} else {593					check_result594				}595			}596		}597	}598599	#[transactional]600	pub fn delete_token_properties(601		collection: &NonfungibleHandle<T>,602		sender: &T::CrossAccountId,603		token_id: TokenId,604		property_keys: Vec<PropertyKey>,605		nesting_budget: &dyn Budget,606	) -> DispatchResult {607		let is_token_create = false;608609		let mut guard = PropertyGuard::new(PropertyGuardData {610			sender,611			collection,612			token_id,613			is_token_create,614			nesting_budget,615		});616617		for key in property_keys {618			Self::delete_token_property(key, &mut guard)?;619		}620621		Ok(())622	}623624	pub fn set_collection_properties(625		collection: &NonfungibleHandle<T>,626		sender: &T::CrossAccountId,627		properties: Vec<Property>,628	) -> DispatchResult {629		<PalletCommon<T>>::set_collection_properties(collection, sender, properties)630	}631632	pub fn delete_collection_properties(633		collection: &CollectionHandle<T>,634		sender: &T::CrossAccountId,635		property_keys: Vec<PropertyKey>,636	) -> DispatchResult {637		<PalletCommon<T>>::delete_collection_properties(collection, sender, property_keys)638	}639640	pub fn set_token_property_permissions(641		collection: &CollectionHandle<T>,642		sender: &T::CrossAccountId,643		property_permissions: Vec<PropertyKeyPermission>,644	) -> DispatchResult {645		<PalletCommon<T>>::set_token_property_permissions(collection, sender, property_permissions)646	}647648	pub fn set_property_permission(649		collection: &CollectionHandle<T>,650		sender: &T::CrossAccountId,651		permission: PropertyKeyPermission,652	) -> DispatchResult {653		<PalletCommon<T>>::set_property_permission(collection, sender, permission)654	}655656	pub fn transfer(657		collection: &NonfungibleHandle<T>,658		from: &T::CrossAccountId,659		to: &T::CrossAccountId,660		token: TokenId,661		nesting_budget: &dyn Budget,662	) -> DispatchResult {663		ensure!(664			collection.limits.transfers_enabled(),665			<CommonError<T>>::TransferNotAllowed666		);667668		let token_data =669			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;670		// TODO: require sender to be token, owner, require admins to go through transfer_from671		ensure!(672			&token_data.owner == from673				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(from)),674			<CommonError<T>>::NoPermission675		);676677		if collection.permissions.access() == AccessMode::AllowList {678			collection.check_allowlist(from)?;679			collection.check_allowlist(to)?;680		}681		<PalletCommon<T>>::ensure_correct_receiver(to)?;682683		let balance_from = <AccountBalance<T>>::get((collection.id, from))684			.checked_sub(1)685			.ok_or(<CommonError<T>>::TokenValueTooLow)?;686		let balance_to = if from != to {687			let balance_to = <AccountBalance<T>>::get((collection.id, to))688				.checked_add(1)689				.ok_or(ArithmeticError::Overflow)?;690691			ensure!(692				balance_to < collection.limits.account_token_ownership_limit(),693				<CommonError<T>>::AccountTokenLimitExceeded,694			);695696			Some(balance_to)697		} else {698			None699		};700701		<PalletStructure<T>>::nest_if_sent_to_token(702			from.clone(),703			to,704			collection.id,705			token,706			nesting_budget,707		)?;708709		// =========710711		<PalletStructure<T>>::unnest_if_nested(&token_data.owner, collection.id, token);712713		<TokenData<T>>::insert(714			(collection.id, token),715			ItemData {716				owner: to.clone(),717				..token_data718			},719		);720721		if let Some(balance_to) = balance_to {722			// from != to723			if balance_from == 0 {724				<AccountBalance<T>>::remove((collection.id, from));725			} else {726				<AccountBalance<T>>::insert((collection.id, from), balance_from);727			}728			<AccountBalance<T>>::insert((collection.id, to), balance_to);729			<Owned<T>>::remove((collection.id, from, token));730			<Owned<T>>::insert((collection.id, to, token), true);731		}732		Self::set_allowance_unchecked(collection, from, token, None, true);733734		<PalletEvm<T>>::deposit_log(735			ERC721Events::Transfer {736				from: *from.as_eth(),737				to: *to.as_eth(),738				token_id: token.into(),739			}740			.to_log(collection_id_to_address(collection.id)),741		);742		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(743			collection.id,744			token,745			from.clone(),746			to.clone(),747			1,748		));749		Ok(())750	}751752	pub fn create_multiple_items(753		collection: &NonfungibleHandle<T>,754		sender: &T::CrossAccountId,755		data: Vec<CreateItemData<T>>,756		nesting_budget: &dyn Budget,757	) -> DispatchResult {758		if !collection.is_owner_or_admin(sender) {759			ensure!(760				collection.permissions.mint_mode(),761				<CommonError<T>>::PublicMintingNotAllowed762			);763			collection.check_allowlist(sender)?;764765			for item in data.iter() {766				collection.check_allowlist(&item.owner)?;767			}768		}769770		for data in data.iter() {771			<PalletCommon<T>>::ensure_correct_receiver(&data.owner)?;772		}773774		let first_token = <TokensMinted<T>>::get(collection.id);775		let tokens_minted = first_token776			.checked_add(data.len() as u32)777			.ok_or(ArithmeticError::Overflow)?;778		ensure!(779			tokens_minted <= collection.limits.token_limit(),780			<CommonError<T>>::CollectionTokenLimitExceeded781		);782783		let mut balances = BTreeMap::new();784		for data in &data {785			let balance = balances786				.entry(&data.owner)787				.or_insert_with(|| <AccountBalance<T>>::get((collection.id, &data.owner)));788			*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;789790			ensure!(791				*balance <= collection.limits.account_token_ownership_limit(),792				<CommonError<T>>::AccountTokenLimitExceeded,793			);794		}795796		for (i, data) in data.iter().enumerate() {797			let token = TokenId(first_token + i as u32 + 1);798799			<PalletStructure<T>>::check_nesting(800				sender.clone(),801				&data.owner,802				collection.id,803				token,804				nesting_budget,805			)?;806		}807808		// =========809810		with_transaction(|| {811			for (i, data) in data.iter().enumerate() {812				let token = first_token + i as u32 + 1;813814				<TokenData<T>>::insert(815					(collection.id, token),816					ItemData {817						// const_data: data.const_data.clone(),818						owner: data.owner.clone(),819					},820				);821822				<PalletStructure<T>>::nest_if_sent_to_token_unchecked(823					&data.owner,824					collection.id,825					TokenId(token),826				);827828				if let Err(e) = Self::set_token_properties(829					collection,830					sender,831					TokenId(token),832					data.properties.clone().into_inner(),833					true,834					nesting_budget,835				) {836					return TransactionOutcome::Rollback(Err(e));837				}838			}839			TransactionOutcome::Commit(Ok(()))840		})?;841842		<TokensMinted<T>>::insert(collection.id, tokens_minted);843		for (account, balance) in balances {844			<AccountBalance<T>>::insert((collection.id, account), balance);845		}846		for (i, data) in data.into_iter().enumerate() {847			let token = first_token + i as u32 + 1;848			<Owned<T>>::insert((collection.id, &data.owner, token), true);849850			<PalletEvm<T>>::deposit_log(851				ERC721Events::Transfer {852					from: H160::default(),853					to: *data.owner.as_eth(),854					token_id: token.into(),855				}856				.to_log(collection_id_to_address(collection.id)),857			);858			<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(859				collection.id,860				TokenId(token),861				data.owner.clone(),862				1,863			));864		}865		Ok(())866	}867868	pub fn set_allowance_unchecked(869		collection: &NonfungibleHandle<T>,870		sender: &T::CrossAccountId,871		token: TokenId,872		spender: Option<&T::CrossAccountId>,873		assume_implicit_eth: bool,874	) {875		if let Some(spender) = spender {876			let old_spender = <Allowance<T>>::get((collection.id, token));877			<Allowance<T>>::insert((collection.id, token), spender);878			// In ERC721 there is only one possible approved user of token, so we set879			// approved user to spender880			<PalletEvm<T>>::deposit_log(881				ERC721Events::Approval {882					owner: *sender.as_eth(),883					approved: *spender.as_eth(),884					token_id: token.into(),885				}886				.to_log(collection_id_to_address(collection.id)),887			);888			// In Unique chain, any token can have any amount of approved users, so we need to889			// set allowance of old owner to 0, and allowance of new owner to 1890			if old_spender.as_ref() != Some(spender) {891				if let Some(old_owner) = old_spender {892					<PalletCommon<T>>::deposit_event(CommonEvent::Approved(893						collection.id,894						token,895						sender.clone(),896						old_owner,897						0,898					));899				}900				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(901					collection.id,902					token,903					sender.clone(),904					spender.clone(),905					1,906				));907			}908		} else {909			let old_spender = <Allowance<T>>::take((collection.id, token));910			if !assume_implicit_eth {911				// In ERC721 there is only one possible approved user of token, so we set912				// approved user to zero address913				<PalletEvm<T>>::deposit_log(914					ERC721Events::Approval {915						owner: *sender.as_eth(),916						approved: H160::default(),917						token_id: token.into(),918					}919					.to_log(collection_id_to_address(collection.id)),920				);921			}922			// In Unique chain, any token can have any amount of approved users, so we need to923			// set allowance of old owner to 0924			if let Some(old_spender) = old_spender {925				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(926					collection.id,927					token,928					sender.clone(),929					old_spender,930					0,931				));932			}933		}934	}935936	pub fn set_allowance(937		collection: &NonfungibleHandle<T>,938		sender: &T::CrossAccountId,939		token: TokenId,940		spender: Option<&T::CrossAccountId>,941	) -> DispatchResult {942		if collection.permissions.access() == AccessMode::AllowList {943			collection.check_allowlist(sender)?;944			if let Some(spender) = spender {945				collection.check_allowlist(spender)?;946			}947		}948949		if let Some(spender) = spender {950			<PalletCommon<T>>::ensure_correct_receiver(spender)?;951		}952953		let token_data =954			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;955		if &token_data.owner != sender {956			ensure!(957				collection.ignores_owned_amount(sender),958				<CommonError<T>>::CantApproveMoreThanOwned959			);960		}961962		// =========963964		Self::set_allowance_unchecked(collection, sender, token, spender, false);965		Ok(())966	}967968	fn check_allowed(969		collection: &NonfungibleHandle<T>,970		spender: &T::CrossAccountId,971		from: &T::CrossAccountId,972		token: TokenId,973		nesting_budget: &dyn Budget,974	) -> DispatchResult {975		if spender.conv_eq(from) {976			return Ok(());977		}978		if collection.permissions.access() == AccessMode::AllowList {979			// `from`, `to` checked in [`transfer`]980			collection.check_allowlist(spender)?;981		}982		if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {983			// TODO: should collection owner be allowed to perform this transfer?984			ensure!(985				<PalletStructure<T>>::check_indirectly_owned(986					spender.clone(),987					source.0,988					source.1,989					None,990					nesting_budget991				)?,992				<CommonError<T>>::ApprovedValueTooLow,993			);994			return Ok(());995		}996		if <Allowance<T>>::get((collection.id, token)).as_ref() == Some(spender) {997			return Ok(());998		}999		ensure!(1000			collection.ignores_allowance(spender),1001			<CommonError<T>>::ApprovedValueTooLow1002		);1003		Ok(())1004	}10051006	pub fn transfer_from(1007		collection: &NonfungibleHandle<T>,1008		spender: &T::CrossAccountId,1009		from: &T::CrossAccountId,1010		to: &T::CrossAccountId,1011		token: TokenId,1012		nesting_budget: &dyn Budget,1013	) -> DispatchResult {1014		Self::check_allowed(collection, spender, from, token, nesting_budget)?;10151016		// =========10171018		// Allowance is reset in [`transfer`]1019		Self::transfer(collection, from, to, token, nesting_budget)1020	}10211022	pub fn burn_from(1023		collection: &NonfungibleHandle<T>,1024		spender: &T::CrossAccountId,1025		from: &T::CrossAccountId,1026		token: TokenId,1027		nesting_budget: &dyn Budget,1028	) -> DispatchResult {1029		Self::check_allowed(collection, spender, from, token, nesting_budget)?;10301031		// =========10321033		Self::burn(collection, from, token)1034	}10351036	pub fn check_nesting(1037		handle: &NonfungibleHandle<T>,1038		sender: T::CrossAccountId,1039		from: (CollectionId, TokenId),1040		under: TokenId,1041		nesting_budget: &dyn Budget,1042	) -> DispatchResult {1043		let nesting = handle.permissions.nesting();10441045		#[cfg(not(feature = "runtime-benchmarks"))]1046		let permissive = false;1047		#[cfg(feature = "runtime-benchmarks")]1048		let permissive = nesting.permissive;10491050		if permissive {1051			// Pass1052		} else if nesting.token_owner1053			&& <PalletStructure<T>>::check_indirectly_owned(1054				sender.clone(),1055				handle.id,1056				under,1057				Some(from),1058				nesting_budget,1059			)? {1060			// Pass1061		} else if nesting.collection_admin && handle.is_owner_or_admin(&sender) {1062			// Pass1063		} else {1064			fail!(<CommonError<T>>::UserIsNotAllowedToNest);1065		}10661067		if let Some(whitelist) = &nesting.restricted {1068			ensure!(1069				whitelist.contains(&from.0),1070				<CommonError<T>>::SourceCollectionIsNotAllowedToNest1071			);1072		}1073		Ok(())1074	}10751076	fn nest(under: (CollectionId, TokenId), to_nest: (CollectionId, TokenId)) {1077		<TokenChildren<T>>::insert((under.0, under.1, (to_nest.0, to_nest.1)), true);1078	}10791080	fn unnest(under: (CollectionId, TokenId), to_unnest: (CollectionId, TokenId)) {1081		<TokenChildren<T>>::remove((under.0, under.1, to_unnest));1082	}10831084	fn collection_has_tokens(collection_id: CollectionId) -> bool {1085		<TokenData<T>>::iter_prefix((collection_id,))1086			.next()1087			.is_some()1088	}10891090	fn token_has_children(collection_id: CollectionId, token_id: TokenId) -> bool {1091		<TokenChildren<T>>::iter_prefix((collection_id, token_id))1092			.next()1093			.is_some()1094	}10951096	pub fn token_children_ids(collection_id: CollectionId, token_id: TokenId) -> Vec<TokenChild> {1097		<TokenChildren<T>>::iter_prefix((collection_id, token_id))1098			.map(|((child_collection_id, child_id), _)| TokenChild {1099				collection: child_collection_id,1100				token: child_id,1101			})1102			.collect()1103	}11041105	/// Delegated to `create_multiple_items`1106	pub fn create_item(1107		collection: &NonfungibleHandle<T>,1108		sender: &T::CrossAccountId,1109		data: CreateItemData<T>,1110		nesting_budget: &dyn Budget,1111	) -> DispatchResult {1112		Self::create_multiple_items(collection, sender, vec![data], nesting_budget)1113	}1114}