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

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::{BoundedVec, ensure, fail, transactional, storage::with_transaction};22use up_data_structs::{23	AccessMode, CollectionId, CustomDataLimit, TokenId, CreateCollectionData, CreateNftExData,24	mapping::TokenAddressMapping, NestingRule, budget::Budget, Property, PropertyPermission,25	PropertyKey, PropertyKeyPermission, Properties, PropertyScope, TrySetProperty,26};27use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};28use pallet_common::{29	Error as CommonError, Pallet as PalletCommon, Event as CommonEvent, CollectionHandle,30	eth::collection_id_to_address,31};32use pallet_structure::Pallet as PalletStructure;33use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};34use sp_core::H160;35use sp_runtime::{ArithmeticError, DispatchError, DispatchResult, TransactionOutcome};36use sp_std::{vec::Vec, vec, collections::btree_map::BTreeMap, collections::btree_set::BTreeSet};37use core::ops::Deref;38use codec::{Encode, Decode, MaxEncodedLen};39use scale_info::TypeInfo;4041pub use pallet::*;42#[cfg(feature = "runtime-benchmarks")]43pub mod benchmarking;44pub mod common;45pub mod erc;46pub mod weights;4748pub type CreateItemData<T> = CreateNftExData<<T as pallet_evm::account::Config>::CrossAccountId>;49pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;5051#[struct_versioning::versioned(version = 2, upper)]52#[derive(Encode, Decode, TypeInfo, MaxEncodedLen)]53pub struct ItemData<CrossAccountId> {54	#[version(..2)]55	pub const_data: BoundedVec<u8, CustomDataLimit>,5657	#[version(..2)]58	pub variable_data: BoundedVec<u8, CustomDataLimit>,5960	pub owner: CrossAccountId,61}6263#[frame_support::pallet]64pub mod pallet {65	use super::*;66	use frame_support::{67		Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key, traits::StorageVersion,68	};69	use frame_system::pallet_prelude::*;70	use up_data_structs::{CollectionId, TokenId};71	use super::weights::WeightInfo;7273	#[pallet::error]74	pub enum Error<T> {75		/// Not Nonfungible item data used to mint in Nonfungible collection.76		NotNonfungibleDataUsedToMintFungibleCollectionToken,77		/// Used amount > 1 with NFT78		NonfungibleItemsHaveNoAmount,79		/// Unable to burn NFT with children80		CantBurnNftWithChildren,81	}8283	#[pallet::config]84	pub trait Config:85		frame_system::Config + pallet_common::Config + pallet_structure::Config + pallet_evm::Config86	{87		type WeightInfo: WeightInfo;88	}8990	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);9192	#[pallet::pallet]93	#[pallet::storage_version(STORAGE_VERSION)]94	#[pallet::generate_store(pub(super) trait Store)]95	pub struct Pallet<T>(_);9697	#[pallet::storage]98	pub type TokensMinted<T: Config> =99		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;100	#[pallet::storage]101	pub type TokensBurnt<T: Config> =102		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;103104	#[pallet::storage]105	pub type TokenData<T: Config> = StorageNMap<106		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),107		Value = ItemData<T::CrossAccountId>,108		QueryKind = OptionQuery,109	>;110111	#[pallet::storage]112	#[pallet::getter(fn token_properties)]113	pub type TokenProperties<T: Config> = StorageNMap<114		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),115		Value = Properties,116		QueryKind = ValueQuery,117		OnEmpty = up_data_structs::TokenProperties,118	>;119120	/// Used to enumerate tokens owned by account121	#[pallet::storage]122	pub type Owned<T: Config> = StorageNMap<123		Key = (124			Key<Twox64Concat, CollectionId>,125			Key<Blake2_128Concat, T::CrossAccountId>,126			Key<Twox64Concat, TokenId>,127		),128		Value = bool,129		QueryKind = ValueQuery,130	>;131132	/// Used to enumerate token's children133	#[pallet::storage]134	#[pallet::getter(fn token_children)]135	pub type TokenChildren<T: Config> = StorageNMap<136		Key = (137			Key<Twox64Concat, CollectionId>,138			Key<Twox64Concat, TokenId>,139			Key<Twox64Concat, (CollectionId, TokenId)>,140		),141		Value = bool,142		QueryKind = ValueQuery,143	>;144145	#[pallet::storage]146	pub type AccountBalance<T: Config> = StorageNMap<147		Key = (148			Key<Twox64Concat, CollectionId>,149			Key<Blake2_128Concat, T::CrossAccountId>,150		),151		Value = u32,152		QueryKind = ValueQuery,153	>;154155	#[pallet::storage]156	pub type Allowance<T: Config> = StorageNMap<157		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),158		Value = T::CrossAccountId,159		QueryKind = OptionQuery,160	>;161162	#[pallet::hooks]163	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {164		fn on_runtime_upgrade() -> Weight {165			if StorageVersion::get::<Pallet<T>>() < StorageVersion::new(1) {166				let mut had_consts = BTreeSet::new();167				<TokenData<T>>::translate::<ItemDataVersion1<T::CrossAccountId>, _>(168					|(collection, token), v| {169						let mut props = vec![];170						if !v.const_data.is_empty() {171							props.push(Property {172								key: b"_old_constData".to_vec().try_into().unwrap(),173								value: v174									.const_data175									.clone()176									.into_inner()177									.try_into()178									.expect("const too long"),179							});180							had_consts.insert(collection);181						}182						if !v.variable_data.is_empty() {183							props.push(Property {184								key: b"_old_variableData".to_vec().try_into().unwrap(),185								value: v186									.variable_data187									.clone()188									.into_inner()189									.try_into()190									.expect("variable too long"),191							})192						}193						if !props.is_empty() {194							Self::set_scoped_token_properties(195								collection,196								token,197								PropertyScope::None,198								props.into_iter(),199							)200							.expect("existing token data exceeds property storage");201						}202						Some(<ItemDataVersion2<T::CrossAccountId>>::from(v))203					},204				);205				for collection in had_consts {206					<PalletCommon<T>>::set_property_permission_unchecked(207						collection,208						PropertyKeyPermission {209							key: b"_old_constData".to_vec().try_into().unwrap(),210							permission: PropertyPermission {211								mutable: false,212								collection_admin: true,213								token_owner: false,214							},215						},216					)217					.expect("failed to configure permission");218				}219			}220221			0222		}223	}224}225226pub struct NonfungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);227impl<T: Config> NonfungibleHandle<T> {228	pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {229		Self(inner)230	}231	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {232		self.0233	}234	pub fn common_mut(&mut self) -> &mut pallet_common::CollectionHandle<T> {235		&mut self.0236	}237}238impl<T: Config> WithRecorder<T> for NonfungibleHandle<T> {239	fn recorder(&self) -> &SubstrateRecorder<T> {240		self.0.recorder()241	}242	fn into_recorder(self) -> SubstrateRecorder<T> {243		self.0.into_recorder()244	}245}246impl<T: Config> Deref for NonfungibleHandle<T> {247	type Target = pallet_common::CollectionHandle<T>;248249	fn deref(&self) -> &Self::Target {250		&self.0251	}252}253254impl<T: Config> Pallet<T> {255	pub fn total_supply(collection: &NonfungibleHandle<T>) -> u32 {256		<TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)257	}258	pub fn token_exists(collection: &NonfungibleHandle<T>, token: TokenId) -> bool {259		<TokenData<T>>::contains_key((collection.id, token))260	}261262	pub fn set_scoped_token_property(263		collection_id: CollectionId,264		token_id: TokenId,265		scope: PropertyScope,266		property: Property,267	) -> DispatchResult {268		TokenProperties::<T>::try_mutate((collection_id, token_id), |properties| {269			properties.try_scoped_set(scope, property.key, property.value)270		})271		.map_err(<CommonError<T>>::from)?;272273		Ok(())274	}275276	pub fn set_scoped_token_properties(277		collection_id: CollectionId,278		token_id: TokenId,279		scope: PropertyScope,280		properties: impl Iterator<Item = Property>,281	) -> DispatchResult {282		TokenProperties::<T>::try_mutate((collection_id, token_id), |stored_properties| {283			stored_properties.try_scoped_set_from_iter(scope, properties)284		})285		.map_err(<CommonError<T>>::from)?;286287		Ok(())288	}289290	pub fn current_token_id(collection_id: CollectionId) -> TokenId {291		TokenId(<TokensMinted<T>>::get(collection_id))292	}293}294295// unchecked calls skips any permission checks296impl<T: Config> Pallet<T> {297	pub fn init_collection(298		owner: T::CrossAccountId,299		data: CreateCollectionData<T::AccountId>,300	) -> Result<CollectionId, DispatchError> {301		<PalletCommon<T>>::init_collection(owner, data)302	}303	pub fn destroy_collection(304		collection: NonfungibleHandle<T>,305		sender: &T::CrossAccountId,306	) -> DispatchResult {307		let id = collection.id;308309		if Self::collection_has_tokens(id) {310			return Err(<CommonError<T>>::CantDestroyNotEmptyCollection.into());311		}312313		// =========314315		PalletCommon::destroy_collection(collection.0, sender)?;316317		<TokenData<T>>::remove_prefix((id,), None);318		<TokenChildren<T>>::remove_prefix((id,), None);319		<Owned<T>>::remove_prefix((id,), None);320		<TokensMinted<T>>::remove(id);321		<TokensBurnt<T>>::remove(id);322		<Allowance<T>>::remove_prefix((id,), None);323		<AccountBalance<T>>::remove_prefix((id,), None);324		Ok(())325	}326327	pub fn burn(328		collection: &NonfungibleHandle<T>,329		sender: &T::CrossAccountId,330		token: TokenId,331	) -> DispatchResult {332		let token_data =333			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;334		ensure!(335			&token_data.owner == sender336				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(sender)),337			<CommonError<T>>::NoPermission338		);339340		if collection.permissions.access() == AccessMode::AllowList {341			collection.check_allowlist(sender)?;342		}343344		if Self::token_has_children(collection.id, token) {345			return Err(<Error<T>>::CantBurnNftWithChildren.into());346		}347348		let burnt = <TokensBurnt<T>>::get(collection.id)349			.checked_add(1)350			.ok_or(ArithmeticError::Overflow)?;351352		let balance = <AccountBalance<T>>::get((collection.id, token_data.owner.clone()))353			.checked_sub(1)354			.ok_or(ArithmeticError::Overflow)?;355356		// =========357358		if balance == 0 {359			<AccountBalance<T>>::remove((collection.id, token_data.owner.clone()));360		} else {361			<AccountBalance<T>>::insert((collection.id, token_data.owner.clone()), balance);362		}363364		<PalletStructure<T>>::unnest_if_nested(&token_data.owner, collection.id, token);365366		<Owned<T>>::remove((collection.id, &token_data.owner, token));367		<TokensBurnt<T>>::insert(collection.id, burnt);368		<TokenData<T>>::remove((collection.id, token));369		<TokenProperties<T>>::remove((collection.id, token));370		let old_spender = <Allowance<T>>::take((collection.id, token));371372		if let Some(old_spender) = old_spender {373			<PalletCommon<T>>::deposit_event(CommonEvent::Approved(374				collection.id,375				token,376				sender.clone(),377				old_spender,378				0,379			));380		}381382		<PalletEvm<T>>::deposit_log(383			ERC721Events::Transfer {384				from: *token_data.owner.as_eth(),385				to: H160::default(),386				token_id: token.into(),387			}388			.to_log(collection_id_to_address(collection.id)),389		);390		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(391			collection.id,392			token,393			token_data.owner,394			1,395		));396		Ok(())397	}398399	pub fn set_token_property(400		collection: &NonfungibleHandle<T>,401		sender: &T::CrossAccountId,402		token_id: TokenId,403		property: Property,404	) -> DispatchResult {405		Self::check_token_change_permission(collection, sender, token_id, &property.key)?;406407		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {408			let property = property.clone();409			properties.try_set(property.key, property.value)410		})411		.map_err(<CommonError<T>>::from)?;412413		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertySet(414			collection.id,415			token_id,416			property.key,417		));418419		Ok(())420	}421422	#[transactional]423	pub fn set_token_properties(424		collection: &NonfungibleHandle<T>,425		sender: &T::CrossAccountId,426		token_id: TokenId,427		properties: Vec<Property>,428	) -> DispatchResult {429		for property in properties {430			Self::set_token_property(collection, sender, token_id, property)?;431		}432433		Ok(())434	}435436	pub fn delete_token_property(437		collection: &NonfungibleHandle<T>,438		sender: &T::CrossAccountId,439		token_id: TokenId,440		property_key: PropertyKey,441	) -> DispatchResult {442		Self::check_token_change_permission(collection, sender, token_id, &property_key)?;443444		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {445			properties.remove(&property_key)446		})447		.map_err(<CommonError<T>>::from)?;448449		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertyDeleted(450			collection.id,451			token_id,452			property_key,453		));454455		Ok(())456	}457458	fn check_token_change_permission(459		collection: &NonfungibleHandle<T>,460		sender: &T::CrossAccountId,461		token_id: TokenId,462		property_key: &PropertyKey,463	) -> DispatchResult {464		let permission = <PalletCommon<T>>::property_permissions(collection.id)465			.get(property_key)466			.cloned()467			.unwrap_or_else(PropertyPermission::none);468469		let token_data = <TokenData<T>>::get((collection.id, token_id))470			.ok_or(<CommonError<T>>::TokenNotFound)?;471472		let check_token_owner = || -> DispatchResult {473			ensure!(&token_data.owner == sender, <CommonError<T>>::NoPermission);474			Ok(())475		};476477		let is_property_exists = TokenProperties::<T>::get((collection.id, token_id))478			.get(property_key)479			.is_some();480481		match permission {482			PropertyPermission { mutable: false, .. } if is_property_exists => {483				Err(<CommonError<T>>::NoPermission.into())484			}485486			PropertyPermission {487				collection_admin,488				token_owner,489				..490			} => {491				let mut check_result = Err(<CommonError<T>>::NoPermission.into());492493				if collection_admin {494					check_result = collection.check_is_owner_or_admin(sender);495				}496497				if token_owner {498					check_result.or_else(|_| check_token_owner())499				} else {500					check_result501				}502			}503		}504	}505506	#[transactional]507	pub fn delete_token_properties(508		collection: &NonfungibleHandle<T>,509		sender: &T::CrossAccountId,510		token_id: TokenId,511		property_keys: Vec<PropertyKey>,512	) -> DispatchResult {513		for key in property_keys {514			Self::delete_token_property(collection, sender, token_id, key)?;515		}516517		Ok(())518	}519520	pub fn set_collection_properties(521		collection: &NonfungibleHandle<T>,522		sender: &T::CrossAccountId,523		properties: Vec<Property>,524	) -> DispatchResult {525		<PalletCommon<T>>::set_collection_properties(collection, sender, properties)526	}527528	pub fn delete_collection_properties(529		collection: &CollectionHandle<T>,530		sender: &T::CrossAccountId,531		property_keys: Vec<PropertyKey>,532	) -> DispatchResult {533		<PalletCommon<T>>::delete_collection_properties(collection, sender, property_keys)534	}535536	pub fn set_property_permissions(537		collection: &CollectionHandle<T>,538		sender: &T::CrossAccountId,539		property_permissions: Vec<PropertyKeyPermission>,540	) -> DispatchResult {541		<PalletCommon<T>>::set_property_permissions(collection, sender, property_permissions)542	}543544	pub fn set_property_permission(545		collection: &CollectionHandle<T>,546		sender: &T::CrossAccountId,547		permission: PropertyKeyPermission,548	) -> DispatchResult {549		<PalletCommon<T>>::set_property_permission(collection, sender, permission)550	}551552	pub fn transfer(553		collection: &NonfungibleHandle<T>,554		from: &T::CrossAccountId,555		to: &T::CrossAccountId,556		token: TokenId,557		nesting_budget: &dyn Budget,558	) -> DispatchResult {559		ensure!(560			collection.limits.transfers_enabled(),561			<CommonError<T>>::TransferNotAllowed562		);563564		let token_data =565			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;566		// TODO: require sender to be token, owner, require admins to go through transfer_from567		ensure!(568			&token_data.owner == from569				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(from)),570			<CommonError<T>>::NoPermission571		);572573		if collection.permissions.access() == AccessMode::AllowList {574			collection.check_allowlist(from)?;575			collection.check_allowlist(to)?;576		}577		<PalletCommon<T>>::ensure_correct_receiver(to)?;578579		let balance_from = <AccountBalance<T>>::get((collection.id, from))580			.checked_sub(1)581			.ok_or(<CommonError<T>>::TokenValueTooLow)?;582		let balance_to = if from != to {583			let balance_to = <AccountBalance<T>>::get((collection.id, to))584				.checked_add(1)585				.ok_or(ArithmeticError::Overflow)?;586587			ensure!(588				balance_to < collection.limits.account_token_ownership_limit(),589				<CommonError<T>>::AccountTokenLimitExceeded,590			);591592			Some(balance_to)593		} else {594			None595		};596597		<PalletStructure<T>>::nest_if_sent_to_token(598			from.clone(),599			to,600			collection.id,601			token,602			nesting_budget,603		)?;604605		// =========606607		<PalletStructure<T>>::unnest_if_nested(from, collection.id, token);608609		<TokenData<T>>::insert(610			(collection.id, token),611			ItemData {612				owner: to.clone(),613				..token_data614			},615		);616617		if let Some(balance_to) = balance_to {618			// from != to619			if balance_from == 0 {620				<AccountBalance<T>>::remove((collection.id, from));621			} else {622				<AccountBalance<T>>::insert((collection.id, from), balance_from);623			}624			<AccountBalance<T>>::insert((collection.id, to), balance_to);625			<Owned<T>>::remove((collection.id, from, token));626			<Owned<T>>::insert((collection.id, to, token), true);627		}628		Self::set_allowance_unchecked(collection, from, token, None, true);629630		<PalletEvm<T>>::deposit_log(631			ERC721Events::Transfer {632				from: *from.as_eth(),633				to: *to.as_eth(),634				token_id: token.into(),635			}636			.to_log(collection_id_to_address(collection.id)),637		);638		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(639			collection.id,640			token,641			from.clone(),642			to.clone(),643			1,644		));645		Ok(())646	}647648	pub fn create_multiple_items(649		collection: &NonfungibleHandle<T>,650		sender: &T::CrossAccountId,651		data: Vec<CreateItemData<T>>,652		nesting_budget: &dyn Budget,653	) -> DispatchResult {654		if !collection.is_owner_or_admin(sender) {655			ensure!(656				collection.permissions.mint_mode(),657				<CommonError<T>>::PublicMintingNotAllowed658			);659			collection.check_allowlist(sender)?;660661			for item in data.iter() {662				collection.check_allowlist(&item.owner)?;663			}664		}665666		for data in data.iter() {667			<PalletCommon<T>>::ensure_correct_receiver(&data.owner)?;668		}669670		let first_token = <TokensMinted<T>>::get(collection.id);671		let tokens_minted = first_token672			.checked_add(data.len() as u32)673			.ok_or(ArithmeticError::Overflow)?;674		ensure!(675			tokens_minted <= collection.limits.token_limit(),676			<CommonError<T>>::CollectionTokenLimitExceeded677		);678679		let mut balances = BTreeMap::new();680		for data in &data {681			let balance = balances682				.entry(&data.owner)683				.or_insert_with(|| <AccountBalance<T>>::get((collection.id, &data.owner)));684			*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;685686			ensure!(687				*balance <= collection.limits.account_token_ownership_limit(),688				<CommonError<T>>::AccountTokenLimitExceeded,689			);690		}691692		for (i, data) in data.iter().enumerate() {693			let token = TokenId(first_token + i as u32 + 1);694695			<PalletStructure<T>>::check_nesting(696				sender.clone(),697				&data.owner,698				collection.id,699				token,700				nesting_budget,701			)?;702		}703704		// =========705706		with_transaction(|| {707			for (i, data) in data.iter().enumerate() {708				let token = first_token + i as u32 + 1;709710				<TokenData<T>>::insert(711					(collection.id, token),712					ItemData {713						// const_data: data.const_data.clone(),714						owner: data.owner.clone(),715					},716				);717718				<PalletStructure<T>>::nest_if_sent_to_token_unchecked(719					&data.owner,720					collection.id,721					TokenId(token),722				);723724				if let Err(e) = Self::set_token_properties(725					collection,726					sender,727					TokenId(token),728					data.properties.clone().into_inner(),729				) {730					return TransactionOutcome::Rollback(Err(e));731				}732			}733			TransactionOutcome::Commit(Ok(()))734		})?;735736		<TokensMinted<T>>::insert(collection.id, tokens_minted);737		for (account, balance) in balances {738			<AccountBalance<T>>::insert((collection.id, account), balance);739		}740		for (i, data) in data.into_iter().enumerate() {741			let token = first_token + i as u32 + 1;742			<Owned<T>>::insert((collection.id, &data.owner, token), true);743744			<PalletEvm<T>>::deposit_log(745				ERC721Events::Transfer {746					from: H160::default(),747					to: *data.owner.as_eth(),748					token_id: token.into(),749				}750				.to_log(collection_id_to_address(collection.id)),751			);752			<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(753				collection.id,754				TokenId(token),755				data.owner.clone(),756				1,757			));758		}759		Ok(())760	}761762	pub fn set_allowance_unchecked(763		collection: &NonfungibleHandle<T>,764		sender: &T::CrossAccountId,765		token: TokenId,766		spender: Option<&T::CrossAccountId>,767		assume_implicit_eth: bool,768	) {769		if let Some(spender) = spender {770			let old_spender = <Allowance<T>>::get((collection.id, token));771			<Allowance<T>>::insert((collection.id, token), spender);772			// In ERC721 there is only one possible approved user of token, so we set773			// approved user to spender774			<PalletEvm<T>>::deposit_log(775				ERC721Events::Approval {776					owner: *sender.as_eth(),777					approved: *spender.as_eth(),778					token_id: token.into(),779				}780				.to_log(collection_id_to_address(collection.id)),781			);782			// In Unique chain, any token can have any amount of approved users, so we need to783			// set allowance of old owner to 0, and allowance of new owner to 1784			if old_spender.as_ref() != Some(spender) {785				if let Some(old_owner) = old_spender {786					<PalletCommon<T>>::deposit_event(CommonEvent::Approved(787						collection.id,788						token,789						sender.clone(),790						old_owner,791						0,792					));793				}794				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(795					collection.id,796					token,797					sender.clone(),798					spender.clone(),799					1,800				));801			}802		} else {803			let old_spender = <Allowance<T>>::take((collection.id, token));804			if !assume_implicit_eth {805				// In ERC721 there is only one possible approved user of token, so we set806				// approved user to zero address807				<PalletEvm<T>>::deposit_log(808					ERC721Events::Approval {809						owner: *sender.as_eth(),810						approved: H160::default(),811						token_id: token.into(),812					}813					.to_log(collection_id_to_address(collection.id)),814				);815			}816			// In Unique chain, any token can have any amount of approved users, so we need to817			// set allowance of old owner to 0818			if let Some(old_spender) = old_spender {819				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(820					collection.id,821					token,822					sender.clone(),823					old_spender,824					0,825				));826			}827		}828	}829830	pub fn set_allowance(831		collection: &NonfungibleHandle<T>,832		sender: &T::CrossAccountId,833		token: TokenId,834		spender: Option<&T::CrossAccountId>,835	) -> DispatchResult {836		if collection.permissions.access() == AccessMode::AllowList {837			collection.check_allowlist(sender)?;838			if let Some(spender) = spender {839				collection.check_allowlist(spender)?;840			}841		}842843		if let Some(spender) = spender {844			<PalletCommon<T>>::ensure_correct_receiver(spender)?;845		}846		let token_data =847			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;848		if &token_data.owner != sender {849			ensure!(850				collection.ignores_owned_amount(sender),851				<CommonError<T>>::CantApproveMoreThanOwned852			);853		}854855		// =========856857		Self::set_allowance_unchecked(collection, sender, token, spender, false);858		Ok(())859	}860861	fn check_allowed(862		collection: &NonfungibleHandle<T>,863		spender: &T::CrossAccountId,864		from: &T::CrossAccountId,865		token: TokenId,866		nesting_budget: &dyn Budget,867	) -> DispatchResult {868		if spender.conv_eq(from) {869			return Ok(());870		}871		if collection.permissions.access() == AccessMode::AllowList {872			// `from`, `to` checked in [`transfer`]873			collection.check_allowlist(spender)?;874		}875		if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {876			// TODO: should collection owner be allowed to perform this transfer?877			ensure!(878				<PalletStructure<T>>::check_indirectly_owned(879					spender.clone(),880					source.0,881					source.1,882					None,883					nesting_budget884				)?,885				<CommonError<T>>::ApprovedValueTooLow,886			);887			return Ok(());888		}889		if <Allowance<T>>::get((collection.id, token)).as_ref() == Some(spender) {890			return Ok(());891		}892		ensure!(893			collection.ignores_allowance(spender),894			<CommonError<T>>::ApprovedValueTooLow895		);896		Ok(())897	}898899	pub fn transfer_from(900		collection: &NonfungibleHandle<T>,901		spender: &T::CrossAccountId,902		from: &T::CrossAccountId,903		to: &T::CrossAccountId,904		token: TokenId,905		nesting_budget: &dyn Budget,906	) -> DispatchResult {907		Self::check_allowed(collection, spender, from, token, nesting_budget)?;908909		// =========910911		// Allowance is reset in [`transfer`]912		Self::transfer(collection, from, to, token, nesting_budget)913	}914915	pub fn burn_from(916		collection: &NonfungibleHandle<T>,917		spender: &T::CrossAccountId,918		from: &T::CrossAccountId,919		token: TokenId,920		nesting_budget: &dyn Budget,921	) -> DispatchResult {922		Self::check_allowed(collection, spender, from, token, nesting_budget)?;923924		// =========925926		Self::burn(collection, from, token)927	}928929	pub fn check_nesting(930		handle: &NonfungibleHandle<T>,931		sender: T::CrossAccountId,932		from: (CollectionId, TokenId),933		under: TokenId,934		nesting_budget: &dyn Budget,935	) -> DispatchResult {936		fn ensure_sender_allowed<T: Config>(937			collection: CollectionId,938			token: TokenId,939			for_nest: (CollectionId, TokenId),940			sender: T::CrossAccountId,941			budget: &dyn Budget,942		) -> DispatchResult {943			ensure!(944				<PalletStructure<T>>::check_indirectly_owned(945					sender,946					collection,947					token,948					Some(for_nest),949					budget950				)?,951				<CommonError<T>>::OnlyOwnerAllowedToNest,952			);953			Ok(())954		}955		match handle.permissions.nesting() {956			NestingRule::Disabled => fail!(<CommonError<T>>::NestingIsDisabled),957			NestingRule::Owner => {958				ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?959			}960			NestingRule::OwnerRestricted(whitelist) => {961				ensure!(962					whitelist.contains(&from.0),963					<CommonError<T>>::SourceCollectionIsNotAllowedToNest964				);965				ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?966			}967		}968		Ok(())969	}970971	fn nest(under: (CollectionId, TokenId), to_nest: (CollectionId, TokenId)) {972		<TokenChildren<T>>::insert((under.0, under.1, (to_nest.0, to_nest.1)), true);973	}974975	fn unnest(under: (CollectionId, TokenId), to_unnest: (CollectionId, TokenId)) {976		<TokenChildren<T>>::remove((under.0, under.1, to_unnest));977	}978979	fn collection_has_tokens(collection_id: CollectionId) -> bool {980		<TokenData<T>>::iter_prefix((collection_id,))981			.next()982			.is_some()983	}984985	fn token_has_children(collection_id: CollectionId, token_id: TokenId) -> bool {986		<TokenChildren<T>>::iter_prefix((collection_id, token_id))987			.next()988			.is_some()989	}990991	/// Delegated to `create_multiple_items`992	pub fn create_item(993		collection: &NonfungibleHandle<T>,994		sender: &T::CrossAccountId,995		data: CreateItemData<T>,996		nesting_budget: &dyn Budget,997	) -> DispatchResult {998		Self::create_multiple_items(collection, sender, vec![data], nesting_budget)999	}1000}