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

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(property: Property, guard: &mut PropertyGuard<'_, T>) -> DispatchResult {492		Self::check_token_change_permission(&property.key, guard)?;493494		<TokenProperties<T>>::try_mutate((guard.collection.id, guard.token), |properties| {495			let property = property.clone();496			properties.try_set(property.key, property.value)497		})498		.map_err(<CommonError<T>>::from)?;499500		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertySet(501			guard.collection.id,502			guard.token,503			property.key,504		));505506		Ok(())507	}508509	#[transactional]510	pub fn set_token_properties(511		collection: &NonfungibleHandle<T>,512		sender: &T::CrossAccountId,513		token_id: TokenId,514		properties: Vec<Property>,515		is_token_create: bool,516		nesting_budget: &dyn Budget,517	) -> DispatchResult {518		let mut guard = PropertyGuard::new(519			sender,520			collection,521			token_id,522			is_token_create,523			nesting_budget,524		);525526		for property in properties {527			Self::set_token_property(property, &mut guard)?;528		}529530		Ok(())531	}532533	pub fn delete_token_property(property_key: PropertyKey, guard: &mut PropertyGuard<'_, T>) -> DispatchResult {534		Self::check_token_change_permission(&property_key, guard)?;535536		<TokenProperties<T>>::try_mutate((guard.collection.id, guard.token), |properties| {537			properties.remove(&property_key)538		})539		.map_err(<CommonError<T>>::from)?;540541		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertyDeleted(542			guard.collection.id,543			guard.token,544			property_key,545		));546547		Ok(())548	}549550	fn check_token_change_permission(property_key: &PropertyKey, guard: &mut PropertyGuard<'_, T>) -> DispatchResult {551		let permission = <PalletCommon<T>>::property_permissions(guard.collection.id)552			.get(property_key)553			.cloned()554			.unwrap_or_else(PropertyPermission::none);555556		let is_property_exists = TokenProperties::<T>::get((guard.collection.id, guard.token))557			.get(property_key)558			.is_some();559560		match permission {561			PropertyPermission { mutable: false, .. } if is_property_exists => {562				Err(<CommonError<T>>::NoPermission.into())563			}564565			PropertyPermission {566				collection_admin,567				token_owner,568				..569			} => {570				//TODO: investigate threats during public minting.571				if guard.is_token_create && (collection_admin || token_owner) {572					return Ok(());573				}574575				let mut check_result = Err(<CommonError<T>>::NoPermission.into());576577				if collection_admin {578					check_result = guard.check_collection_admin();579				}580581				if token_owner {582					check_result.or_else(|_| guard.check_token_owner())583				} else {584					check_result585				}586			}587		}588	}589590	#[transactional]591	pub fn delete_token_properties(592		collection: &NonfungibleHandle<T>,593		sender: &T::CrossAccountId,594		token_id: TokenId,595		property_keys: Vec<PropertyKey>,596		nesting_budget: &dyn Budget,597	) -> DispatchResult {598		let is_token_create = false;599600		let mut guard = PropertyGuard::new(601			sender,602			collection,603			token_id,604			is_token_create,605			nesting_budget,606		);607608		for key in property_keys {609			Self::delete_token_property(key, &mut guard)?;610		}611612		Ok(())613	}614615	pub fn set_collection_properties(616		collection: &NonfungibleHandle<T>,617		sender: &T::CrossAccountId,618		properties: Vec<Property>,619	) -> DispatchResult {620		<PalletCommon<T>>::set_collection_properties(collection, sender, properties)621	}622623	pub fn delete_collection_properties(624		collection: &CollectionHandle<T>,625		sender: &T::CrossAccountId,626		property_keys: Vec<PropertyKey>,627	) -> DispatchResult {628		<PalletCommon<T>>::delete_collection_properties(collection, sender, property_keys)629	}630631	pub fn set_token_property_permissions(632		collection: &CollectionHandle<T>,633		sender: &T::CrossAccountId,634		property_permissions: Vec<PropertyKeyPermission>,635	) -> DispatchResult {636		<PalletCommon<T>>::set_token_property_permissions(collection, sender, property_permissions)637	}638639	pub fn set_property_permission(640		collection: &CollectionHandle<T>,641		sender: &T::CrossAccountId,642		permission: PropertyKeyPermission,643	) -> DispatchResult {644		<PalletCommon<T>>::set_property_permission(collection, sender, permission)645	}646647	pub fn transfer(648		collection: &NonfungibleHandle<T>,649		from: &T::CrossAccountId,650		to: &T::CrossAccountId,651		token: TokenId,652		nesting_budget: &dyn Budget,653	) -> DispatchResult {654		ensure!(655			collection.limits.transfers_enabled(),656			<CommonError<T>>::TransferNotAllowed657		);658659		let token_data =660			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;661		// TODO: require sender to be token, owner, require admins to go through transfer_from662		ensure!(663			&token_data.owner == from664				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(from)),665			<CommonError<T>>::NoPermission666		);667668		if collection.permissions.access() == AccessMode::AllowList {669			collection.check_allowlist(from)?;670			collection.check_allowlist(to)?;671		}672		<PalletCommon<T>>::ensure_correct_receiver(to)?;673674		let balance_from = <AccountBalance<T>>::get((collection.id, from))675			.checked_sub(1)676			.ok_or(<CommonError<T>>::TokenValueTooLow)?;677		let balance_to = if from != to {678			let balance_to = <AccountBalance<T>>::get((collection.id, to))679				.checked_add(1)680				.ok_or(ArithmeticError::Overflow)?;681682			ensure!(683				balance_to < collection.limits.account_token_ownership_limit(),684				<CommonError<T>>::AccountTokenLimitExceeded,685			);686687			Some(balance_to)688		} else {689			None690		};691692		<PalletStructure<T>>::nest_if_sent_to_token(693			from.clone(),694			to,695			collection.id,696			token,697			nesting_budget,698		)?;699700		// =========701702		<PalletStructure<T>>::unnest_if_nested(&token_data.owner, collection.id, token);703704		<TokenData<T>>::insert(705			(collection.id, token),706			ItemData {707				owner: to.clone(),708				..token_data709			},710		);711712		if let Some(balance_to) = balance_to {713			// from != to714			if balance_from == 0 {715				<AccountBalance<T>>::remove((collection.id, from));716			} else {717				<AccountBalance<T>>::insert((collection.id, from), balance_from);718			}719			<AccountBalance<T>>::insert((collection.id, to), balance_to);720			<Owned<T>>::remove((collection.id, from, token));721			<Owned<T>>::insert((collection.id, to, token), true);722		}723		Self::set_allowance_unchecked(collection, from, token, None, true);724725		<PalletEvm<T>>::deposit_log(726			ERC721Events::Transfer {727				from: *from.as_eth(),728				to: *to.as_eth(),729				token_id: token.into(),730			}731			.to_log(collection_id_to_address(collection.id)),732		);733		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(734			collection.id,735			token,736			from.clone(),737			to.clone(),738			1,739		));740		Ok(())741	}742743	pub fn create_multiple_items(744		collection: &NonfungibleHandle<T>,745		sender: &T::CrossAccountId,746		data: Vec<CreateItemData<T>>,747		nesting_budget: &dyn Budget,748	) -> DispatchResult {749		if !collection.is_owner_or_admin(sender) {750			ensure!(751				collection.permissions.mint_mode(),752				<CommonError<T>>::PublicMintingNotAllowed753			);754			collection.check_allowlist(sender)?;755756			for item in data.iter() {757				collection.check_allowlist(&item.owner)?;758			}759		}760761		for data in data.iter() {762			<PalletCommon<T>>::ensure_correct_receiver(&data.owner)?;763		}764765		let first_token = <TokensMinted<T>>::get(collection.id);766		let tokens_minted = first_token767			.checked_add(data.len() as u32)768			.ok_or(ArithmeticError::Overflow)?;769		ensure!(770			tokens_minted <= collection.limits.token_limit(),771			<CommonError<T>>::CollectionTokenLimitExceeded772		);773774		let mut balances = BTreeMap::new();775		for data in &data {776			let balance = balances777				.entry(&data.owner)778				.or_insert_with(|| <AccountBalance<T>>::get((collection.id, &data.owner)));779			*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;780781			ensure!(782				*balance <= collection.limits.account_token_ownership_limit(),783				<CommonError<T>>::AccountTokenLimitExceeded,784			);785		}786787		for (i, data) in data.iter().enumerate() {788			let token = TokenId(first_token + i as u32 + 1);789790			<PalletStructure<T>>::check_nesting(791				sender.clone(),792				&data.owner,793				collection.id,794				token,795				nesting_budget,796			)?;797		}798799		// =========800801		with_transaction(|| {802			for (i, data) in data.iter().enumerate() {803				let token = first_token + i as u32 + 1;804805				<TokenData<T>>::insert(806					(collection.id, token),807					ItemData {808						// const_data: data.const_data.clone(),809						owner: data.owner.clone(),810					},811				);812813				<PalletStructure<T>>::nest_if_sent_to_token_unchecked(814					&data.owner,815					collection.id,816					TokenId(token),817				);818819				if let Err(e) = Self::set_token_properties(820					collection,821					sender,822					TokenId(token),823					data.properties.clone().into_inner(),824					true,825					nesting_budget,826				) {827					return TransactionOutcome::Rollback(Err(e));828				}829			}830			TransactionOutcome::Commit(Ok(()))831		})?;832833		<TokensMinted<T>>::insert(collection.id, tokens_minted);834		for (account, balance) in balances {835			<AccountBalance<T>>::insert((collection.id, account), balance);836		}837		for (i, data) in data.into_iter().enumerate() {838			let token = first_token + i as u32 + 1;839			<Owned<T>>::insert((collection.id, &data.owner, token), true);840841			<PalletEvm<T>>::deposit_log(842				ERC721Events::Transfer {843					from: H160::default(),844					to: *data.owner.as_eth(),845					token_id: token.into(),846				}847				.to_log(collection_id_to_address(collection.id)),848			);849			<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(850				collection.id,851				TokenId(token),852				data.owner.clone(),853				1,854			));855		}856		Ok(())857	}858859	pub fn set_allowance_unchecked(860		collection: &NonfungibleHandle<T>,861		sender: &T::CrossAccountId,862		token: TokenId,863		spender: Option<&T::CrossAccountId>,864		assume_implicit_eth: bool,865	) {866		if let Some(spender) = spender {867			let old_spender = <Allowance<T>>::get((collection.id, token));868			<Allowance<T>>::insert((collection.id, token), spender);869			// In ERC721 there is only one possible approved user of token, so we set870			// approved user to spender871			<PalletEvm<T>>::deposit_log(872				ERC721Events::Approval {873					owner: *sender.as_eth(),874					approved: *spender.as_eth(),875					token_id: token.into(),876				}877				.to_log(collection_id_to_address(collection.id)),878			);879			// In Unique chain, any token can have any amount of approved users, so we need to880			// set allowance of old owner to 0, and allowance of new owner to 1881			if old_spender.as_ref() != Some(spender) {882				if let Some(old_owner) = old_spender {883					<PalletCommon<T>>::deposit_event(CommonEvent::Approved(884						collection.id,885						token,886						sender.clone(),887						old_owner,888						0,889					));890				}891				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(892					collection.id,893					token,894					sender.clone(),895					spender.clone(),896					1,897				));898			}899		} else {900			let old_spender = <Allowance<T>>::take((collection.id, token));901			if !assume_implicit_eth {902				// In ERC721 there is only one possible approved user of token, so we set903				// approved user to zero address904				<PalletEvm<T>>::deposit_log(905					ERC721Events::Approval {906						owner: *sender.as_eth(),907						approved: H160::default(),908						token_id: token.into(),909					}910					.to_log(collection_id_to_address(collection.id)),911				);912			}913			// In Unique chain, any token can have any amount of approved users, so we need to914			// set allowance of old owner to 0915			if let Some(old_spender) = old_spender {916				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(917					collection.id,918					token,919					sender.clone(),920					old_spender,921					0,922				));923			}924		}925	}926927	pub fn set_allowance(928		collection: &NonfungibleHandle<T>,929		sender: &T::CrossAccountId,930		token: TokenId,931		spender: Option<&T::CrossAccountId>,932	) -> DispatchResult {933		if collection.permissions.access() == AccessMode::AllowList {934			collection.check_allowlist(sender)?;935			if let Some(spender) = spender {936				collection.check_allowlist(spender)?;937			}938		}939940		if let Some(spender) = spender {941			<PalletCommon<T>>::ensure_correct_receiver(spender)?;942		}943944		let token_data =945			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;946		if &token_data.owner != sender {947			ensure!(948				collection.ignores_owned_amount(sender),949				<CommonError<T>>::CantApproveMoreThanOwned950			);951		}952953		// =========954955		Self::set_allowance_unchecked(collection, sender, token, spender, false);956		Ok(())957	}958959	fn check_allowed(960		collection: &NonfungibleHandle<T>,961		spender: &T::CrossAccountId,962		from: &T::CrossAccountId,963		token: TokenId,964		nesting_budget: &dyn Budget,965	) -> DispatchResult {966		if spender.conv_eq(from) {967			return Ok(());968		}969		if collection.permissions.access() == AccessMode::AllowList {970			// `from`, `to` checked in [`transfer`]971			collection.check_allowlist(spender)?;972		}973		if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {974			// TODO: should collection owner be allowed to perform this transfer?975			ensure!(976				<PalletStructure<T>>::check_indirectly_owned(977					spender.clone(),978					source.0,979					source.1,980					None,981					nesting_budget982				)?,983				<CommonError<T>>::ApprovedValueTooLow,984			);985			return Ok(());986		}987		if <Allowance<T>>::get((collection.id, token)).as_ref() == Some(spender) {988			return Ok(());989		}990		ensure!(991			collection.ignores_allowance(spender),992			<CommonError<T>>::ApprovedValueTooLow993		);994		Ok(())995	}996997	pub fn transfer_from(998		collection: &NonfungibleHandle<T>,999		spender: &T::CrossAccountId,1000		from: &T::CrossAccountId,1001		to: &T::CrossAccountId,1002		token: TokenId,1003		nesting_budget: &dyn Budget,1004	) -> DispatchResult {1005		Self::check_allowed(collection, spender, from, token, nesting_budget)?;10061007		// =========10081009		// Allowance is reset in [`transfer`]1010		Self::transfer(collection, from, to, token, nesting_budget)1011	}10121013	pub fn burn_from(1014		collection: &NonfungibleHandle<T>,1015		spender: &T::CrossAccountId,1016		from: &T::CrossAccountId,1017		token: TokenId,1018		nesting_budget: &dyn Budget,1019	) -> DispatchResult {1020		Self::check_allowed(collection, spender, from, token, nesting_budget)?;10211022		// =========10231024		Self::burn(collection, from, token)1025	}10261027	pub fn check_nesting(1028		handle: &NonfungibleHandle<T>,1029		sender: T::CrossAccountId,1030		from: (CollectionId, TokenId),1031		under: TokenId,1032		nesting_budget: &dyn Budget,1033	) -> DispatchResult {1034		let nesting = handle.permissions.nesting();10351036		#[cfg(not(feature = "runtime-benchmarks"))]1037		let permissive = false;1038		#[cfg(feature = "runtime-benchmarks")]1039		let permissive = nesting.permissive;10401041		if permissive {1042			// Pass1043		} else if nesting.token_owner1044			&& <PalletStructure<T>>::check_indirectly_owned(1045				sender.clone(),1046				handle.id,1047				under,1048				Some(from),1049				nesting_budget,1050			)? {1051			// Pass1052		} else if nesting.collection_admin && handle.is_owner_or_admin(&sender) {1053			// Pass1054		} else {1055			fail!(<CommonError<T>>::UserIsNotAllowedToNest);1056		}10571058		if let Some(whitelist) = &nesting.restricted {1059			ensure!(1060				whitelist.contains(&from.0),1061				<CommonError<T>>::SourceCollectionIsNotAllowedToNest1062			);1063		}1064		Ok(())1065	}10661067	fn nest(under: (CollectionId, TokenId), to_nest: (CollectionId, TokenId)) {1068		<TokenChildren<T>>::insert((under.0, under.1, (to_nest.0, to_nest.1)), true);1069	}10701071	fn unnest(under: (CollectionId, TokenId), to_unnest: (CollectionId, TokenId)) {1072		<TokenChildren<T>>::remove((under.0, under.1, to_unnest));1073	}10741075	fn collection_has_tokens(collection_id: CollectionId) -> bool {1076		<TokenData<T>>::iter_prefix((collection_id,))1077			.next()1078			.is_some()1079	}10801081	fn token_has_children(collection_id: CollectionId, token_id: TokenId) -> bool {1082		<TokenChildren<T>>::iter_prefix((collection_id, token_id))1083			.next()1084			.is_some()1085	}10861087	pub fn token_children_ids(collection_id: CollectionId, token_id: TokenId) -> Vec<TokenChild> {1088		<TokenChildren<T>>::iter_prefix((collection_id, token_id))1089			.map(|((child_collection_id, child_id), _)| TokenChild {1090				collection: child_collection_id,1091				token: child_id,1092			})1093			.collect()1094	}10951096	/// Delegated to `create_multiple_items`1097	pub fn create_item(1098		collection: &NonfungibleHandle<T>,1099		sender: &T::CrossAccountId,1100		data: CreateItemData<T>,1101		nesting_budget: &dyn Budget,1102	) -> DispatchResult {1103		Self::create_multiple_items(collection, sender, vec![data], nesting_budget)1104	}1105}