git.delta.rocks / unique-network / refs/commits / 504df77ef385

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, NestingRule, budget::Budget, Property, PropertyPermission,31	PropertyKey, PropertyKeyPermission, Properties, PropertyScope, TrySetProperty, TokenChild,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	/// Used to enumerate tokens owned by account128	#[pallet::storage]129	pub type Owned<T: Config> = StorageNMap<130		Key = (131			Key<Twox64Concat, CollectionId>,132			Key<Blake2_128Concat, T::CrossAccountId>,133			Key<Twox64Concat, TokenId>,134		),135		Value = bool,136		QueryKind = ValueQuery,137	>;138139	/// Used to enumerate token's children140	#[pallet::storage]141	#[pallet::getter(fn token_children)]142	pub type TokenChildren<T: Config> = StorageNMap<143		Key = (144			Key<Twox64Concat, CollectionId>,145			Key<Twox64Concat, TokenId>,146			Key<Twox64Concat, (CollectionId, TokenId)>,147		),148		Value = bool,149		QueryKind = ValueQuery,150	>;151152	#[pallet::storage]153	pub type AccountBalance<T: Config> = StorageNMap<154		Key = (155			Key<Twox64Concat, CollectionId>,156			Key<Blake2_128Concat, T::CrossAccountId>,157		),158		Value = u32,159		QueryKind = ValueQuery,160	>;161162	#[pallet::storage]163	pub type Allowance<T: Config> = StorageNMap<164		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),165		Value = T::CrossAccountId,166		QueryKind = OptionQuery,167	>;168169	#[pallet::hooks]170	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {171		fn on_runtime_upgrade() -> Weight {172			if StorageVersion::get::<Pallet<T>>() < StorageVersion::new(1) {173				let mut had_consts = BTreeSet::new();174				<TokenData<T>>::translate::<ItemDataVersion1<T::CrossAccountId>, _>(175					|(collection, token), v| {176						let mut props = vec![];177						if !v.const_data.is_empty() {178							props.push(Property {179								key: b"_old_constData".to_vec().try_into().unwrap(),180								value: v181									.const_data182									.clone()183									.into_inner()184									.try_into()185									.expect("const too long"),186							});187							had_consts.insert(collection);188						}189						if !v.variable_data.is_empty() {190							props.push(Property {191								key: b"_old_variableData".to_vec().try_into().unwrap(),192								value: v193									.variable_data194									.clone()195									.into_inner()196									.try_into()197									.expect("variable too long"),198							})199						}200						if !props.is_empty() {201							Self::set_scoped_token_properties(202								collection,203								token,204								PropertyScope::None,205								props.into_iter(),206							)207							.expect("existing token data exceeds property storage");208						}209						Some(<ItemDataVersion2<T::CrossAccountId>>::from(v))210					},211				);212				for collection in had_consts {213					<PalletCommon<T>>::set_property_permission_unchecked(214						collection,215						PropertyKeyPermission {216							key: b"_old_constData".to_vec().try_into().unwrap(),217							permission: PropertyPermission {218								mutable: false,219								collection_admin: true,220								token_owner: false,221							},222						},223					)224					.expect("failed to configure permission");225				}226			}227228			0229		}230	}231}232233pub struct NonfungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);234impl<T: Config> NonfungibleHandle<T> {235	pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {236		Self(inner)237	}238	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {239		self.0240	}241	pub fn common_mut(&mut self) -> &mut pallet_common::CollectionHandle<T> {242		&mut self.0243	}244}245impl<T: Config> WithRecorder<T> for NonfungibleHandle<T> {246	fn recorder(&self) -> &SubstrateRecorder<T> {247		self.0.recorder()248	}249	fn into_recorder(self) -> SubstrateRecorder<T> {250		self.0.into_recorder()251	}252}253impl<T: Config> Deref for NonfungibleHandle<T> {254	type Target = pallet_common::CollectionHandle<T>;255256	fn deref(&self) -> &Self::Target {257		&self.0258	}259}260261impl<T: Config> Pallet<T> {262	pub fn total_supply(collection: &NonfungibleHandle<T>) -> u32 {263		<TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)264	}265	pub fn token_exists(collection: &NonfungibleHandle<T>, token: TokenId) -> bool {266		<TokenData<T>>::contains_key((collection.id, token))267	}268269	pub fn set_scoped_token_property(270		collection_id: CollectionId,271		token_id: TokenId,272		scope: PropertyScope,273		property: Property,274	) -> DispatchResult {275		TokenProperties::<T>::try_mutate((collection_id, token_id), |properties| {276			properties.try_scoped_set(scope, property.key, property.value)277		})278		.map_err(<CommonError<T>>::from)?;279280		Ok(())281	}282283	pub fn set_scoped_token_properties(284		collection_id: CollectionId,285		token_id: TokenId,286		scope: PropertyScope,287		properties: impl Iterator<Item = Property>,288	) -> DispatchResult {289		TokenProperties::<T>::try_mutate((collection_id, token_id), |stored_properties| {290			stored_properties.try_scoped_set_from_iter(scope, properties)291		})292		.map_err(<CommonError<T>>::from)?;293294		Ok(())295	}296297	pub fn current_token_id(collection_id: CollectionId) -> TokenId {298		TokenId(<TokensMinted<T>>::get(collection_id))299	}300}301302// unchecked calls skips any permission checks303impl<T: Config> Pallet<T> {304	pub fn init_collection(305		owner: T::CrossAccountId,306		data: CreateCollectionData<T::AccountId>,307		is_external: bool,308	) -> Result<CollectionId, DispatchError> {309		<PalletCommon<T>>::init_collection(owner, data, is_external)310	}311	pub fn destroy_collection(312		collection: NonfungibleHandle<T>,313		sender: &T::CrossAccountId,314	) -> DispatchResult {315		let id = collection.id;316317		if Self::collection_has_tokens(id) {318			return Err(<CommonError<T>>::CantDestroyNotEmptyCollection.into());319		}320321		// =========322323		PalletCommon::destroy_collection(collection.0, sender)?;324325		<TokenData<T>>::remove_prefix((id,), None);326		<TokenChildren<T>>::remove_prefix((id,), None);327		<Owned<T>>::remove_prefix((id,), None);328		<TokensMinted<T>>::remove(id);329		<TokensBurnt<T>>::remove(id);330		<Allowance<T>>::remove_prefix((id,), None);331		<AccountBalance<T>>::remove_prefix((id,), None);332		Ok(())333	}334335	pub fn burn(336		collection: &NonfungibleHandle<T>,337		sender: &T::CrossAccountId,338		token: TokenId,339	) -> DispatchResult {340		let token_data =341			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;342		ensure!(343			&token_data.owner == sender344				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(sender)),345			<CommonError<T>>::NoPermission346		);347348		if collection.permissions.access() == AccessMode::AllowList {349			collection.check_allowlist(sender)?;350		}351352		if Self::token_has_children(collection.id, token) {353			return Err(<Error<T>>::CantBurnNftWithChildren.into());354		}355356		let burnt = <TokensBurnt<T>>::get(collection.id)357			.checked_add(1)358			.ok_or(ArithmeticError::Overflow)?;359360		let balance = <AccountBalance<T>>::get((collection.id, token_data.owner.clone()))361			.checked_sub(1)362			.ok_or(ArithmeticError::Overflow)?;363364		// =========365366		if balance == 0 {367			<AccountBalance<T>>::remove((collection.id, token_data.owner.clone()));368		} else {369			<AccountBalance<T>>::insert((collection.id, token_data.owner.clone()), balance);370		}371372		<PalletStructure<T>>::unnest_if_nested(&token_data.owner, collection.id, token);373374		<Owned<T>>::remove((collection.id, &token_data.owner, token));375		<TokensBurnt<T>>::insert(collection.id, burnt);376		<TokenData<T>>::remove((collection.id, token));377		<TokenProperties<T>>::remove((collection.id, token));378		let old_spender = <Allowance<T>>::take((collection.id, token));379380		if let Some(old_spender) = old_spender {381			<PalletCommon<T>>::deposit_event(CommonEvent::Approved(382				collection.id,383				token,384				token_data.owner.clone(),385				old_spender,386				0,387			));388		}389390		<PalletEvm<T>>::deposit_log(391			ERC721Events::Transfer {392				from: *token_data.owner.as_eth(),393				to: H160::default(),394				token_id: token.into(),395			}396			.to_log(collection_id_to_address(collection.id)),397		);398		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(399			collection.id,400			token,401			token_data.owner,402			1,403		));404		Ok(())405	}406407	#[transactional]408	pub fn burn_recursively(409		collection: &NonfungibleHandle<T>,410		sender: &T::CrossAccountId,411		token: TokenId,412		self_budget: &dyn Budget,413		breadth_budget: &dyn Budget,414	) -> DispatchResultWithPostInfo {415		ensure!(self_budget.consume(), <StructureError<T>>::DepthLimit,);416417		let current_token_account =418			T::CrossTokenAddressMapping::token_to_address(collection.id, token);419420		let mut weight = 0 as Weight;421422		// This method is transactional, if user in fact doesn't have permissions to remove token -423		// tokens removed here will be restored after rejected transaction424		for ((collection, token), _) in <TokenChildren<T>>::iter_prefix((collection.id, token)) {425			ensure!(breadth_budget.consume(), <StructureError<T>>::BreadthLimit,);426			let PostDispatchInfo { actual_weight, .. } =427				<PalletStructure<T>>::burn_item_recursively(428					current_token_account.clone(),429					collection,430					token,431					self_budget,432					breadth_budget,433				)?;434			if let Some(actual_weight) = actual_weight {435				weight = weight.saturating_add(actual_weight);436			}437		}438439		Self::burn(collection, sender, token)?;440		DispatchResultWithPostInfo::Ok(PostDispatchInfo {441			actual_weight: Some(weight + <SelfWeightOf<T>>::burn_item()),442			pays_fee: Pays::Yes,443		})444	}445446	pub fn set_token_property(447		collection: &NonfungibleHandle<T>,448		sender: &T::CrossAccountId,449		token_id: TokenId,450		property: Property,451		is_token_create: bool,452	) -> DispatchResult {453		Self::check_token_change_permission(454			collection,455			sender,456			token_id,457			&property.key,458			is_token_create,459		)?;460461		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {462			let property = property.clone();463			properties.try_set(property.key, property.value)464		})465		.map_err(<CommonError<T>>::from)?;466467		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertySet(468			collection.id,469			token_id,470			property.key,471		));472473		Ok(())474	}475476	#[transactional]477	pub fn set_token_properties(478		collection: &NonfungibleHandle<T>,479		sender: &T::CrossAccountId,480		token_id: TokenId,481		properties: Vec<Property>,482		is_token_create: bool,483	) -> DispatchResult {484		for property in properties {485			Self::set_token_property(collection, sender, token_id, property, is_token_create)?;486		}487488		Ok(())489	}490491	pub fn delete_token_property(492		collection: &NonfungibleHandle<T>,493		sender: &T::CrossAccountId,494		token_id: TokenId,495		property_key: PropertyKey,496	) -> DispatchResult {497		Self::check_token_change_permission(collection, sender, token_id, &property_key, false)?;498499		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {500			properties.remove(&property_key)501		})502		.map_err(<CommonError<T>>::from)?;503504		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertyDeleted(505			collection.id,506			token_id,507			property_key,508		));509510		Ok(())511	}512513	fn check_token_change_permission(514		collection: &NonfungibleHandle<T>,515		sender: &T::CrossAccountId,516		token_id: TokenId,517		property_key: &PropertyKey,518		is_token_create: bool,519	) -> DispatchResult {520		let permission = <PalletCommon<T>>::property_permissions(collection.id)521			.get(property_key)522			.cloned()523			.unwrap_or_else(PropertyPermission::none);524525		let token_data = <TokenData<T>>::get((collection.id, token_id))526			.ok_or(<CommonError<T>>::TokenNotFound)?;527528		let check_token_owner = || -> DispatchResult {529			ensure!(&token_data.owner == sender, <CommonError<T>>::NoPermission);530			Ok(())531		};532533		let is_property_exists = TokenProperties::<T>::get((collection.id, token_id))534			.get(property_key)535			.is_some();536537		match permission {538			PropertyPermission { mutable: false, .. } if is_property_exists => {539				Err(<CommonError<T>>::NoPermission.into())540			}541542			PropertyPermission {543				collection_admin,544				token_owner,545				..546			} => {547				//TODO: investigate threats during public minting.548				if is_token_create && (collection_admin || token_owner) {549					return Ok(());550				}551552				let mut check_result = Err(<CommonError<T>>::NoPermission.into());553554				if collection_admin {555					check_result = collection.check_is_owner_or_admin(sender);556				}557558				if token_owner {559					check_result.or_else(|_| check_token_owner())560				} else {561					check_result562				}563			}564		}565	}566567	#[transactional]568	pub fn delete_token_properties(569		collection: &NonfungibleHandle<T>,570		sender: &T::CrossAccountId,571		token_id: TokenId,572		property_keys: Vec<PropertyKey>,573	) -> DispatchResult {574		for key in property_keys {575			Self::delete_token_property(collection, sender, token_id, key)?;576		}577578		Ok(())579	}580581	pub fn set_collection_properties(582		collection: &NonfungibleHandle<T>,583		sender: &T::CrossAccountId,584		properties: Vec<Property>,585	) -> DispatchResult {586		<PalletCommon<T>>::set_collection_properties(collection, sender, properties)587	}588589	pub fn delete_collection_properties(590		collection: &CollectionHandle<T>,591		sender: &T::CrossAccountId,592		property_keys: Vec<PropertyKey>,593	) -> DispatchResult {594		<PalletCommon<T>>::delete_collection_properties(collection, sender, property_keys)595	}596597	pub fn set_property_permissions(598		collection: &CollectionHandle<T>,599		sender: &T::CrossAccountId,600		property_permissions: Vec<PropertyKeyPermission>,601	) -> DispatchResult {602		<PalletCommon<T>>::set_property_permissions(collection, sender, property_permissions)603	}604605	pub fn set_property_permission(606		collection: &CollectionHandle<T>,607		sender: &T::CrossAccountId,608		permission: PropertyKeyPermission,609	) -> DispatchResult {610		<PalletCommon<T>>::set_property_permission(collection, sender, permission)611	}612613	pub fn transfer(614		collection: &NonfungibleHandle<T>,615		from: &T::CrossAccountId,616		to: &T::CrossAccountId,617		token: TokenId,618		nesting_budget: &dyn Budget,619	) -> DispatchResult {620		ensure!(621			collection.limits.transfers_enabled(),622			<CommonError<T>>::TransferNotAllowed623		);624625		let token_data =626			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;627		// TODO: require sender to be token, owner, require admins to go through transfer_from628		ensure!(629			&token_data.owner == from630				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(from)),631			<CommonError<T>>::NoPermission632		);633634		if collection.permissions.access() == AccessMode::AllowList {635			collection.check_allowlist(from)?;636			collection.check_allowlist(to)?;637		}638		<PalletCommon<T>>::ensure_correct_receiver(to)?;639640		let balance_from = <AccountBalance<T>>::get((collection.id, from))641			.checked_sub(1)642			.ok_or(<CommonError<T>>::TokenValueTooLow)?;643		let balance_to = if from != to {644			let balance_to = <AccountBalance<T>>::get((collection.id, to))645				.checked_add(1)646				.ok_or(ArithmeticError::Overflow)?;647648			ensure!(649				balance_to < collection.limits.account_token_ownership_limit(),650				<CommonError<T>>::AccountTokenLimitExceeded,651			);652653			Some(balance_to)654		} else {655			None656		};657658		<PalletStructure<T>>::nest_if_sent_to_token(659			from.clone(),660			to,661			collection.id,662			token,663			nesting_budget,664		)?;665666		// =========667668		<PalletStructure<T>>::unnest_if_nested(&token_data.owner, collection.id, token);669670		<TokenData<T>>::insert(671			(collection.id, token),672			ItemData {673				owner: to.clone(),674				..token_data675			},676		);677678		if let Some(balance_to) = balance_to {679			// from != to680			if balance_from == 0 {681				<AccountBalance<T>>::remove((collection.id, from));682			} else {683				<AccountBalance<T>>::insert((collection.id, from), balance_from);684			}685			<AccountBalance<T>>::insert((collection.id, to), balance_to);686			<Owned<T>>::remove((collection.id, from, token));687			<Owned<T>>::insert((collection.id, to, token), true);688		}689		Self::set_allowance_unchecked(collection, from, token, None, true);690691		<PalletEvm<T>>::deposit_log(692			ERC721Events::Transfer {693				from: *from.as_eth(),694				to: *to.as_eth(),695				token_id: token.into(),696			}697			.to_log(collection_id_to_address(collection.id)),698		);699		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(700			collection.id,701			token,702			from.clone(),703			to.clone(),704			1,705		));706		Ok(())707	}708709	pub fn create_multiple_items(710		collection: &NonfungibleHandle<T>,711		sender: &T::CrossAccountId,712		data: Vec<CreateItemData<T>>,713		nesting_budget: &dyn Budget,714	) -> DispatchResult {715		if !collection.is_owner_or_admin(sender) {716			ensure!(717				collection.permissions.mint_mode(),718				<CommonError<T>>::PublicMintingNotAllowed719			);720			collection.check_allowlist(sender)?;721722			for item in data.iter() {723				collection.check_allowlist(&item.owner)?;724			}725		}726727		for data in data.iter() {728			<PalletCommon<T>>::ensure_correct_receiver(&data.owner)?;729		}730731		let first_token = <TokensMinted<T>>::get(collection.id);732		let tokens_minted = first_token733			.checked_add(data.len() as u32)734			.ok_or(ArithmeticError::Overflow)?;735		ensure!(736			tokens_minted <= collection.limits.token_limit(),737			<CommonError<T>>::CollectionTokenLimitExceeded738		);739740		let mut balances = BTreeMap::new();741		for data in &data {742			let balance = balances743				.entry(&data.owner)744				.or_insert_with(|| <AccountBalance<T>>::get((collection.id, &data.owner)));745			*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;746747			ensure!(748				*balance <= collection.limits.account_token_ownership_limit(),749				<CommonError<T>>::AccountTokenLimitExceeded,750			);751		}752753		for (i, data) in data.iter().enumerate() {754			let token = TokenId(first_token + i as u32 + 1);755756			<PalletStructure<T>>::check_nesting(757				sender.clone(),758				&data.owner,759				collection.id,760				token,761				nesting_budget,762			)?;763		}764765		// =========766767		with_transaction(|| {768			for (i, data) in data.iter().enumerate() {769				let token = first_token + i as u32 + 1;770771				<TokenData<T>>::insert(772					(collection.id, token),773					ItemData {774						// const_data: data.const_data.clone(),775						owner: data.owner.clone(),776					},777				);778779				<PalletStructure<T>>::nest_if_sent_to_token_unchecked(780					&data.owner,781					collection.id,782					TokenId(token),783				);784785				if let Err(e) = Self::set_token_properties(786					collection,787					sender,788					TokenId(token),789					data.properties.clone().into_inner(),790					true,791				) {792					return TransactionOutcome::Rollback(Err(e));793				}794			}795			TransactionOutcome::Commit(Ok(()))796		})?;797798		<TokensMinted<T>>::insert(collection.id, tokens_minted);799		for (account, balance) in balances {800			<AccountBalance<T>>::insert((collection.id, account), balance);801		}802		for (i, data) in data.into_iter().enumerate() {803			let token = first_token + i as u32 + 1;804			<Owned<T>>::insert((collection.id, &data.owner, token), true);805806			<PalletEvm<T>>::deposit_log(807				ERC721Events::Transfer {808					from: H160::default(),809					to: *data.owner.as_eth(),810					token_id: token.into(),811				}812				.to_log(collection_id_to_address(collection.id)),813			);814			<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(815				collection.id,816				TokenId(token),817				data.owner.clone(),818				1,819			));820		}821		Ok(())822	}823824	pub fn set_allowance_unchecked(825		collection: &NonfungibleHandle<T>,826		sender: &T::CrossAccountId,827		token: TokenId,828		spender: Option<&T::CrossAccountId>,829		assume_implicit_eth: bool,830	) {831		if let Some(spender) = spender {832			let old_spender = <Allowance<T>>::get((collection.id, token));833			<Allowance<T>>::insert((collection.id, token), spender);834			// In ERC721 there is only one possible approved user of token, so we set835			// approved user to spender836			<PalletEvm<T>>::deposit_log(837				ERC721Events::Approval {838					owner: *sender.as_eth(),839					approved: *spender.as_eth(),840					token_id: token.into(),841				}842				.to_log(collection_id_to_address(collection.id)),843			);844			// In Unique chain, any token can have any amount of approved users, so we need to845			// set allowance of old owner to 0, and allowance of new owner to 1846			if old_spender.as_ref() != Some(spender) {847				if let Some(old_owner) = old_spender {848					<PalletCommon<T>>::deposit_event(CommonEvent::Approved(849						collection.id,850						token,851						sender.clone(),852						old_owner,853						0,854					));855				}856				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(857					collection.id,858					token,859					sender.clone(),860					spender.clone(),861					1,862				));863			}864		} else {865			let old_spender = <Allowance<T>>::take((collection.id, token));866			if !assume_implicit_eth {867				// In ERC721 there is only one possible approved user of token, so we set868				// approved user to zero address869				<PalletEvm<T>>::deposit_log(870					ERC721Events::Approval {871						owner: *sender.as_eth(),872						approved: H160::default(),873						token_id: token.into(),874					}875					.to_log(collection_id_to_address(collection.id)),876				);877			}878			// In Unique chain, any token can have any amount of approved users, so we need to879			// set allowance of old owner to 0880			if let Some(old_spender) = old_spender {881				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(882					collection.id,883					token,884					sender.clone(),885					old_spender,886					0,887				));888			}889		}890	}891892	pub fn set_allowance(893		collection: &NonfungibleHandle<T>,894		sender: &T::CrossAccountId,895		token: TokenId,896		spender: Option<&T::CrossAccountId>,897	) -> DispatchResult {898		if collection.permissions.access() == AccessMode::AllowList {899			collection.check_allowlist(sender)?;900			if let Some(spender) = spender {901				collection.check_allowlist(spender)?;902			}903		}904905		if let Some(spender) = spender {906			<PalletCommon<T>>::ensure_correct_receiver(spender)?;907		}908909		let token_data =910			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;911		if &token_data.owner != sender {912			ensure!(913				collection.ignores_owned_amount(sender),914				<CommonError<T>>::CantApproveMoreThanOwned915			);916		}917918		// =========919920		Self::set_allowance_unchecked(collection, sender, token, spender, false);921		Ok(())922	}923924	fn check_allowed(925		collection: &NonfungibleHandle<T>,926		spender: &T::CrossAccountId,927		from: &T::CrossAccountId,928		token: TokenId,929		nesting_budget: &dyn Budget,930	) -> DispatchResult {931		if spender.conv_eq(from) {932			return Ok(());933		}934		if collection.permissions.access() == AccessMode::AllowList {935			// `from`, `to` checked in [`transfer`]936			collection.check_allowlist(spender)?;937		}938		if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {939			// TODO: should collection owner be allowed to perform this transfer?940			ensure!(941				<PalletStructure<T>>::check_indirectly_owned(942					spender.clone(),943					source.0,944					source.1,945					None,946					nesting_budget947				)?,948				<CommonError<T>>::ApprovedValueTooLow,949			);950			return Ok(());951		}952		if <Allowance<T>>::get((collection.id, token)).as_ref() == Some(spender) {953			return Ok(());954		}955		ensure!(956			collection.ignores_allowance(spender),957			<CommonError<T>>::ApprovedValueTooLow958		);959		Ok(())960	}961962	pub fn transfer_from(963		collection: &NonfungibleHandle<T>,964		spender: &T::CrossAccountId,965		from: &T::CrossAccountId,966		to: &T::CrossAccountId,967		token: TokenId,968		nesting_budget: &dyn Budget,969	) -> DispatchResult {970		Self::check_allowed(collection, spender, from, token, nesting_budget)?;971972		// =========973974		// Allowance is reset in [`transfer`]975		Self::transfer(collection, from, to, token, nesting_budget)976	}977978	pub fn burn_from(979		collection: &NonfungibleHandle<T>,980		spender: &T::CrossAccountId,981		from: &T::CrossAccountId,982		token: TokenId,983		nesting_budget: &dyn Budget,984	) -> DispatchResult {985		Self::check_allowed(collection, spender, from, token, nesting_budget)?;986987		// =========988989		Self::burn(collection, from, token)990	}991992	pub fn check_nesting(993		handle: &NonfungibleHandle<T>,994		sender: T::CrossAccountId,995		from: (CollectionId, TokenId),996		under: TokenId,997		nesting_budget: &dyn Budget,998	) -> DispatchResult {999		fn ensure_sender_allowed<T: Config>(1000			collection: CollectionId,1001			token: TokenId,1002			for_nest: (CollectionId, TokenId),1003			sender: T::CrossAccountId,1004			budget: &dyn Budget,1005		) -> DispatchResult {1006			ensure!(1007				<PalletStructure<T>>::check_indirectly_owned(1008					sender,1009					collection,1010					token,1011					Some(for_nest),1012					budget1013				)?,1014				<CommonError<T>>::OnlyOwnerAllowedToNest,1015			);1016			Ok(())1017		}1018		match handle.permissions.nesting() {1019			NestingRule::Disabled => fail!(<CommonError<T>>::NestingIsDisabled),1020			NestingRule::Owner => {1021				ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?1022			}1023			NestingRule::OwnerRestricted(whitelist) => {1024				ensure!(1025					whitelist.contains(&from.0),1026					<CommonError<T>>::SourceCollectionIsNotAllowedToNest1027				);1028				ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?1029			}1030			NestingRule::Permissive => {}1031		}1032		Ok(())1033	}10341035	fn nest(under: (CollectionId, TokenId), to_nest: (CollectionId, TokenId)) {1036		<TokenChildren<T>>::insert((under.0, under.1, (to_nest.0, to_nest.1)), true);1037	}10381039	fn unnest(under: (CollectionId, TokenId), to_unnest: (CollectionId, TokenId)) {1040		<TokenChildren<T>>::remove((under.0, under.1, to_unnest));1041	}10421043	fn collection_has_tokens(collection_id: CollectionId) -> bool {1044		<TokenData<T>>::iter_prefix((collection_id,))1045			.next()1046			.is_some()1047	}10481049	fn token_has_children(collection_id: CollectionId, token_id: TokenId) -> bool {1050		<TokenChildren<T>>::iter_prefix((collection_id, token_id))1051			.next()1052			.is_some()1053	}10541055	pub fn token_children_ids(collection_id: CollectionId, token_id: TokenId) -> Vec<TokenChild> {1056		<TokenChildren<T>>::iter_prefix((collection_id, token_id))1057			.map(|((child_collection_id, child_id), _)| TokenChild {1058				collection: child_collection_id,1059				token: child_id,1060			})1061			.collect()1062	}10631064	/// Delegated to `create_multiple_items`1065	pub fn create_item(1066		collection: &NonfungibleHandle<T>,1067		sender: &T::CrossAccountId,1068		data: CreateItemData<T>,1069		nesting_budget: &dyn Budget,1070	) -> DispatchResult {1071		Self::create_multiple_items(collection, sender, vec![data], nesting_budget)1072	}1073}