git.delta.rocks / unique-network / refs/commits / 1f98ccc154b2

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!(&token_data.owner == sender, <CommonError<T>>::NoPermission);383384		if collection.permissions.access() == AccessMode::AllowList {385			collection.check_allowlist(sender)?;386		}387388		if Self::token_has_children(collection.id, token) {389			return Err(<Error<T>>::CantBurnNftWithChildren.into());390		}391392		let burnt = <TokensBurnt<T>>::get(collection.id)393			.checked_add(1)394			.ok_or(ArithmeticError::Overflow)?;395396		let balance = <AccountBalance<T>>::get((collection.id, token_data.owner.clone()))397			.checked_sub(1)398			.ok_or(ArithmeticError::Overflow)?;399400		// =========401402		if balance == 0 {403			<AccountBalance<T>>::remove((collection.id, token_data.owner.clone()));404		} else {405			<AccountBalance<T>>::insert((collection.id, token_data.owner.clone()), balance);406		}407408		<PalletStructure<T>>::unnest_if_nested(&token_data.owner, collection.id, token);409410		<Owned<T>>::remove((collection.id, &token_data.owner, token));411		<TokensBurnt<T>>::insert(collection.id, burnt);412		<TokenData<T>>::remove((collection.id, token));413		<TokenProperties<T>>::remove((collection.id, token));414		<TokenAuxProperties<T>>::remove_prefix((collection.id, token), None);415		let old_spender = <Allowance<T>>::take((collection.id, token));416417		if let Some(old_spender) = old_spender {418			<PalletCommon<T>>::deposit_event(CommonEvent::Approved(419				collection.id,420				token,421				token_data.owner.clone(),422				old_spender,423				0,424			));425		}426427		<PalletEvm<T>>::deposit_log(428			ERC721Events::Transfer {429				from: *token_data.owner.as_eth(),430				to: H160::default(),431				token_id: token.into(),432			}433			.to_log(collection_id_to_address(collection.id)),434		);435		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(436			collection.id,437			token,438			token_data.owner,439			1,440		));441		Ok(())442	}443444	#[transactional]445	pub fn burn_recursively(446		collection: &NonfungibleHandle<T>,447		sender: &T::CrossAccountId,448		token: TokenId,449		self_budget: &dyn Budget,450		breadth_budget: &dyn Budget,451	) -> DispatchResultWithPostInfo {452		ensure!(self_budget.consume(), <StructureError<T>>::DepthLimit,);453454		let current_token_account =455			T::CrossTokenAddressMapping::token_to_address(collection.id, token);456457		let mut weight = 0 as Weight;458459		// This method is transactional, if user in fact doesn't have permissions to remove token -460		// tokens removed here will be restored after rejected transaction461		for ((collection, token), _) in <TokenChildren<T>>::iter_prefix((collection.id, token)) {462			ensure!(breadth_budget.consume(), <StructureError<T>>::BreadthLimit,);463			let PostDispatchInfo { actual_weight, .. } =464				<PalletStructure<T>>::burn_item_recursively(465					current_token_account.clone(),466					collection,467					token,468					self_budget,469					breadth_budget,470				)?;471			if let Some(actual_weight) = actual_weight {472				weight = weight.saturating_add(actual_weight);473			}474		}475476		Self::burn(collection, sender, token)?;477		DispatchResultWithPostInfo::Ok(PostDispatchInfo {478			actual_weight: Some(weight + <SelfWeightOf<T>>::burn_item()),479			pays_fee: Pays::Yes,480		})481	}482483	pub fn set_token_property(484		collection: &NonfungibleHandle<T>,485		sender: &T::CrossAccountId,486		token_id: TokenId,487		property: Property,488		is_token_create: bool,489	) -> DispatchResult {490		Self::check_token_change_permission(491			collection,492			sender,493			token_id,494			&property.key,495			is_token_create,496		)?;497498		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {499			let property = property.clone();500			properties.try_set(property.key, property.value)501		})502		.map_err(<CommonError<T>>::from)?;503504		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertySet(505			collection.id,506			token_id,507			property.key,508		));509510		Ok(())511	}512513	#[transactional]514	pub fn set_token_properties(515		collection: &NonfungibleHandle<T>,516		sender: &T::CrossAccountId,517		token_id: TokenId,518		properties: Vec<Property>,519		is_token_create: bool,520	) -> DispatchResult {521		for property in properties {522			Self::set_token_property(collection, sender, token_id, property, is_token_create)?;523		}524525		Ok(())526	}527528	pub fn delete_token_property(529		collection: &NonfungibleHandle<T>,530		sender: &T::CrossAccountId,531		token_id: TokenId,532		property_key: PropertyKey,533	) -> DispatchResult {534		Self::check_token_change_permission(collection, sender, token_id, &property_key, false)?;535536		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {537			properties.remove(&property_key)538		})539		.map_err(<CommonError<T>>::from)?;540541		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertyDeleted(542			collection.id,543			token_id,544			property_key,545		));546547		Ok(())548	}549550	fn check_token_change_permission(551		collection: &NonfungibleHandle<T>,552		sender: &T::CrossAccountId,553		token_id: TokenId,554		property_key: &PropertyKey,555		is_token_create: bool,556	) -> DispatchResult {557		let permission = <PalletCommon<T>>::property_permissions(collection.id)558			.get(property_key)559			.cloned()560			.unwrap_or_else(PropertyPermission::none);561562		let token_data = <TokenData<T>>::get((collection.id, token_id))563			.ok_or(<CommonError<T>>::TokenNotFound)?;564565		let check_token_owner = || -> DispatchResult {566			ensure!(&token_data.owner == sender, <CommonError<T>>::NoPermission);567			Ok(())568		};569570		let is_property_exists = TokenProperties::<T>::get((collection.id, token_id))571			.get(property_key)572			.is_some();573574		match permission {575			PropertyPermission { mutable: false, .. } if is_property_exists => {576				Err(<CommonError<T>>::NoPermission.into())577			}578579			PropertyPermission {580				collection_admin,581				token_owner,582				..583			} => {584				//TODO: investigate threats during public minting.585				if is_token_create && (collection_admin || token_owner) {586					return Ok(());587				}588589				let mut check_result = Err(<CommonError<T>>::NoPermission.into());590591				if collection_admin {592					check_result = collection.check_is_owner_or_admin(sender);593				}594595				if token_owner {596					check_result.or_else(|_| check_token_owner())597				} else {598					check_result599				}600			}601		}602	}603604	#[transactional]605	pub fn delete_token_properties(606		collection: &NonfungibleHandle<T>,607		sender: &T::CrossAccountId,608		token_id: TokenId,609		property_keys: Vec<PropertyKey>,610	) -> DispatchResult {611		for key in property_keys {612			Self::delete_token_property(collection, sender, token_id, key)?;613		}614615		Ok(())616	}617618	pub fn set_collection_properties(619		collection: &NonfungibleHandle<T>,620		sender: &T::CrossAccountId,621		properties: Vec<Property>,622	) -> DispatchResult {623		<PalletCommon<T>>::set_collection_properties(collection, sender, properties)624	}625626	pub fn delete_collection_properties(627		collection: &CollectionHandle<T>,628		sender: &T::CrossAccountId,629		property_keys: Vec<PropertyKey>,630	) -> DispatchResult {631		<PalletCommon<T>>::delete_collection_properties(collection, sender, property_keys)632	}633634	pub fn set_token_property_permissions(635		collection: &CollectionHandle<T>,636		sender: &T::CrossAccountId,637		property_permissions: Vec<PropertyKeyPermission>,638	) -> DispatchResult {639		<PalletCommon<T>>::set_token_property_permissions(collection, sender, property_permissions)640	}641642	pub fn set_property_permission(643		collection: &CollectionHandle<T>,644		sender: &T::CrossAccountId,645		permission: PropertyKeyPermission,646	) -> DispatchResult {647		<PalletCommon<T>>::set_property_permission(collection, sender, permission)648	}649650	pub fn transfer(651		collection: &NonfungibleHandle<T>,652		from: &T::CrossAccountId,653		to: &T::CrossAccountId,654		token: TokenId,655		nesting_budget: &dyn Budget,656	) -> DispatchResult {657		ensure!(658			collection.limits.transfers_enabled(),659			<CommonError<T>>::TransferNotAllowed660		);661662		let token_data =663			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;664		ensure!(&token_data.owner == from, <CommonError<T>>::NoPermission);665666		if collection.permissions.access() == AccessMode::AllowList {667			collection.check_allowlist(from)?;668			collection.check_allowlist(to)?;669		}670		<PalletCommon<T>>::ensure_correct_receiver(to)?;671672		let balance_from = <AccountBalance<T>>::get((collection.id, from))673			.checked_sub(1)674			.ok_or(<CommonError<T>>::TokenValueTooLow)?;675		let balance_to = if from != to {676			let balance_to = <AccountBalance<T>>::get((collection.id, to))677				.checked_add(1)678				.ok_or(ArithmeticError::Overflow)?;679680			ensure!(681				balance_to < collection.limits.account_token_ownership_limit(),682				<CommonError<T>>::AccountTokenLimitExceeded,683			);684685			Some(balance_to)686		} else {687			None688		};689690		<PalletStructure<T>>::nest_if_sent_to_token(691			from.clone(),692			to,693			collection.id,694			token,695			nesting_budget,696		)?;697698		// =========699700		<PalletStructure<T>>::unnest_if_nested(&token_data.owner, collection.id, token);701702		<TokenData<T>>::insert(703			(collection.id, token),704			ItemData {705				owner: to.clone(),706				..token_data707			},708		);709710		if let Some(balance_to) = balance_to {711			// from != to712			if balance_from == 0 {713				<AccountBalance<T>>::remove((collection.id, from));714			} else {715				<AccountBalance<T>>::insert((collection.id, from), balance_from);716			}717			<AccountBalance<T>>::insert((collection.id, to), balance_to);718			<Owned<T>>::remove((collection.id, from, token));719			<Owned<T>>::insert((collection.id, to, token), true);720		}721		Self::set_allowance_unchecked(collection, from, token, None, true);722723		<PalletEvm<T>>::deposit_log(724			ERC721Events::Transfer {725				from: *from.as_eth(),726				to: *to.as_eth(),727				token_id: token.into(),728			}729			.to_log(collection_id_to_address(collection.id)),730		);731		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(732			collection.id,733			token,734			from.clone(),735			to.clone(),736			1,737		));738		Ok(())739	}740741	pub fn create_multiple_items(742		collection: &NonfungibleHandle<T>,743		sender: &T::CrossAccountId,744		data: Vec<CreateItemData<T>>,745		nesting_budget: &dyn Budget,746	) -> DispatchResult {747		if !collection.is_owner_or_admin(sender) {748			ensure!(749				collection.permissions.mint_mode(),750				<CommonError<T>>::PublicMintingNotAllowed751			);752			collection.check_allowlist(sender)?;753754			for item in data.iter() {755				collection.check_allowlist(&item.owner)?;756			}757		}758759		for data in data.iter() {760			<PalletCommon<T>>::ensure_correct_receiver(&data.owner)?;761		}762763		let first_token = <TokensMinted<T>>::get(collection.id);764		let tokens_minted = first_token765			.checked_add(data.len() as u32)766			.ok_or(ArithmeticError::Overflow)?;767		ensure!(768			tokens_minted <= collection.limits.token_limit(),769			<CommonError<T>>::CollectionTokenLimitExceeded770		);771772		let mut balances = BTreeMap::new();773		for data in &data {774			let balance = balances775				.entry(&data.owner)776				.or_insert_with(|| <AccountBalance<T>>::get((collection.id, &data.owner)));777			*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;778779			ensure!(780				*balance <= collection.limits.account_token_ownership_limit(),781				<CommonError<T>>::AccountTokenLimitExceeded,782			);783		}784785		for (i, data) in data.iter().enumerate() {786			let token = TokenId(first_token + i as u32 + 1);787788			<PalletStructure<T>>::check_nesting(789				sender.clone(),790				&data.owner,791				collection.id,792				token,793				nesting_budget,794			)?;795		}796797		// =========798799		with_transaction(|| {800			for (i, data) in data.iter().enumerate() {801				let token = first_token + i as u32 + 1;802803				<TokenData<T>>::insert(804					(collection.id, token),805					ItemData {806						// const_data: data.const_data.clone(),807						owner: data.owner.clone(),808					},809				);810811				<PalletStructure<T>>::nest_if_sent_to_token_unchecked(812					&data.owner,813					collection.id,814					TokenId(token),815				);816817				if let Err(e) = Self::set_token_properties(818					collection,819					sender,820					TokenId(token),821					data.properties.clone().into_inner(),822					true,823				) {824					return TransactionOutcome::Rollback(Err(e));825				}826			}827			TransactionOutcome::Commit(Ok(()))828		})?;829830		<TokensMinted<T>>::insert(collection.id, tokens_minted);831		for (account, balance) in balances {832			<AccountBalance<T>>::insert((collection.id, account), balance);833		}834		for (i, data) in data.into_iter().enumerate() {835			let token = first_token + i as u32 + 1;836			<Owned<T>>::insert((collection.id, &data.owner, token), true);837838			<PalletEvm<T>>::deposit_log(839				ERC721Events::Transfer {840					from: H160::default(),841					to: *data.owner.as_eth(),842					token_id: token.into(),843				}844				.to_log(collection_id_to_address(collection.id)),845			);846			<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(847				collection.id,848				TokenId(token),849				data.owner.clone(),850				1,851			));852		}853		Ok(())854	}855856	pub fn set_allowance_unchecked(857		collection: &NonfungibleHandle<T>,858		sender: &T::CrossAccountId,859		token: TokenId,860		spender: Option<&T::CrossAccountId>,861		assume_implicit_eth: bool,862	) {863		if let Some(spender) = spender {864			let old_spender = <Allowance<T>>::get((collection.id, token));865			<Allowance<T>>::insert((collection.id, token), spender);866			// In ERC721 there is only one possible approved user of token, so we set867			// approved user to spender868			<PalletEvm<T>>::deposit_log(869				ERC721Events::Approval {870					owner: *sender.as_eth(),871					approved: *spender.as_eth(),872					token_id: token.into(),873				}874				.to_log(collection_id_to_address(collection.id)),875			);876			// In Unique chain, any token can have any amount of approved users, so we need to877			// set allowance of old owner to 0, and allowance of new owner to 1878			if old_spender.as_ref() != Some(spender) {879				if let Some(old_owner) = old_spender {880					<PalletCommon<T>>::deposit_event(CommonEvent::Approved(881						collection.id,882						token,883						sender.clone(),884						old_owner,885						0,886					));887				}888				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(889					collection.id,890					token,891					sender.clone(),892					spender.clone(),893					1,894				));895			}896		} else {897			let old_spender = <Allowance<T>>::take((collection.id, token));898			if !assume_implicit_eth {899				// In ERC721 there is only one possible approved user of token, so we set900				// approved user to zero address901				<PalletEvm<T>>::deposit_log(902					ERC721Events::Approval {903						owner: *sender.as_eth(),904						approved: H160::default(),905						token_id: token.into(),906					}907					.to_log(collection_id_to_address(collection.id)),908				);909			}910			// In Unique chain, any token can have any amount of approved users, so we need to911			// set allowance of old owner to 0912			if let Some(old_spender) = old_spender {913				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(914					collection.id,915					token,916					sender.clone(),917					old_spender,918					0,919				));920			}921		}922	}923924	pub fn set_allowance(925		collection: &NonfungibleHandle<T>,926		sender: &T::CrossAccountId,927		token: TokenId,928		spender: Option<&T::CrossAccountId>,929	) -> DispatchResult {930		if collection.permissions.access() == AccessMode::AllowList {931			collection.check_allowlist(sender)?;932			if let Some(spender) = spender {933				collection.check_allowlist(spender)?;934			}935		}936937		if let Some(spender) = spender {938			<PalletCommon<T>>::ensure_correct_receiver(spender)?;939		}940941		let token_data =942			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;943		if &token_data.owner != sender {944			ensure!(945				collection.ignores_owned_amount(sender),946				<CommonError<T>>::CantApproveMoreThanOwned947			);948		}949950		// =========951952		Self::set_allowance_unchecked(collection, sender, token, spender, false);953		Ok(())954	}955956	fn check_allowed(957		collection: &NonfungibleHandle<T>,958		spender: &T::CrossAccountId,959		from: &T::CrossAccountId,960		token: TokenId,961		nesting_budget: &dyn Budget,962	) -> DispatchResult {963		if spender.conv_eq(from) {964			return Ok(());965		}966		if collection.permissions.access() == AccessMode::AllowList {967			// `from`, `to` checked in [`transfer`]968			collection.check_allowlist(spender)?;969		}970971		if collection.limits.owner_can_transfer() && collection.is_owner_or_admin(spender) {972			return Ok(());973		}974975		if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {976			ensure!(977				<PalletStructure<T>>::check_indirectly_owned(978					spender.clone(),979					source.0,980					source.1,981					None,982					nesting_budget983				)?,984				<CommonError<T>>::ApprovedValueTooLow,985			);986			return Ok(());987		}988		if <Allowance<T>>::get((collection.id, token)).as_ref() == Some(spender) {989			return Ok(());990		}991		ensure!(992			collection.ignores_allowance(spender),993			<CommonError<T>>::ApprovedValueTooLow994		);995		Ok(())996	}997998	pub fn transfer_from(999		collection: &NonfungibleHandle<T>,1000		spender: &T::CrossAccountId,1001		from: &T::CrossAccountId,1002		to: &T::CrossAccountId,1003		token: TokenId,1004		nesting_budget: &dyn Budget,1005	) -> DispatchResult {1006		Self::check_allowed(collection, spender, from, token, nesting_budget)?;10071008		// =========10091010		// Allowance is reset in [`transfer`]1011		Self::transfer(collection, from, to, token, nesting_budget)1012	}10131014	pub fn burn_from(1015		collection: &NonfungibleHandle<T>,1016		spender: &T::CrossAccountId,1017		from: &T::CrossAccountId,1018		token: TokenId,1019		nesting_budget: &dyn Budget,1020	) -> DispatchResult {1021		Self::check_allowed(collection, spender, from, token, nesting_budget)?;10221023		// =========10241025		Self::burn(collection, from, token)1026	}10271028	pub fn check_nesting(1029		handle: &NonfungibleHandle<T>,1030		sender: T::CrossAccountId,1031		from: (CollectionId, TokenId),1032		under: TokenId,1033		nesting_budget: &dyn Budget,1034	) -> DispatchResult {1035		let nesting = handle.permissions.nesting();10361037		#[cfg(not(feature = "runtime-benchmarks"))]1038		let permissive = false;1039		#[cfg(feature = "runtime-benchmarks")]1040		let permissive = nesting.permissive;10411042		if permissive {1043			// Pass1044		} else if nesting.token_owner1045			&& <PalletStructure<T>>::check_indirectly_owned(1046				sender.clone(),1047				handle.id,1048				under,1049				Some(from),1050				nesting_budget,1051			)? {1052			// Pass1053		} else if nesting.collection_admin && handle.is_owner_or_admin(&sender) {1054			// Pass1055		} else {1056			fail!(<CommonError<T>>::UserIsNotAllowedToNest);1057		}10581059		if let Some(whitelist) = &nesting.restricted {1060			ensure!(1061				whitelist.contains(&from.0),1062				<CommonError<T>>::SourceCollectionIsNotAllowedToNest1063			);1064		}1065		Ok(())1066	}10671068	fn nest(under: (CollectionId, TokenId), to_nest: (CollectionId, TokenId)) {1069		<TokenChildren<T>>::insert((under.0, under.1, (to_nest.0, to_nest.1)), true);1070	}10711072	fn unnest(under: (CollectionId, TokenId), to_unnest: (CollectionId, TokenId)) {1073		<TokenChildren<T>>::remove((under.0, under.1, to_unnest));1074	}10751076	fn collection_has_tokens(collection_id: CollectionId) -> bool {1077		<TokenData<T>>::iter_prefix((collection_id,))1078			.next()1079			.is_some()1080	}10811082	fn token_has_children(collection_id: CollectionId, token_id: TokenId) -> bool {1083		<TokenChildren<T>>::iter_prefix((collection_id, token_id))1084			.next()1085			.is_some()1086	}10871088	pub fn token_children_ids(collection_id: CollectionId, token_id: TokenId) -> Vec<TokenChild> {1089		<TokenChildren<T>>::iter_prefix((collection_id, token_id))1090			.map(|((child_collection_id, child_id), _)| TokenChild {1091				collection: child_collection_id,1092				token: child_id,1093			})1094			.collect()1095	}10961097	/// Delegated to `create_multiple_items`1098	pub fn create_item(1099		collection: &NonfungibleHandle<T>,1100		sender: &T::CrossAccountId,1101		data: CreateItemData<T>,1102		nesting_budget: &dyn Budget,1103	) -> DispatchResult {1104		Self::create_multiple_items(collection, sender, vec![data], nesting_budget)1105	}1106}