git.delta.rocks / unique-network / refs/commits / 79ec93ec606f

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_set::BTreeSet};37use core::ops::Deref;38use sp_std::collections::btree_map::BTreeMap;39use codec::{Encode, Decode, MaxEncodedLen};40use scale_info::TypeInfo;4142pub use pallet::*;43#[cfg(feature = "runtime-benchmarks")]44pub mod benchmarking;45pub mod common;46pub mod erc;47pub mod weights;4849pub type CreateItemData<T> = CreateNftExData<<T as pallet_evm::account::Config>::CrossAccountId>;50pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;5152#[struct_versioning::versioned(version = 2, upper)]53#[derive(Encode, Decode, TypeInfo, MaxEncodedLen)]54pub struct ItemData<CrossAccountId> {55	#[version(..2)]56	pub const_data: BoundedVec<u8, CustomDataLimit>,5758	#[version(..2)]59	pub variable_data: BoundedVec<u8, CustomDataLimit>,6061	pub owner: CrossAccountId,62}6364#[frame_support::pallet]65pub mod pallet {66	use super::*;67	use frame_support::{68		Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key, traits::StorageVersion,69	};70	use frame_system::pallet_prelude::*;71	use up_data_structs::{CollectionId, TokenId};72	use super::weights::WeightInfo;7374	#[pallet::error]75	pub enum Error<T> {76		/// Not Nonfungible item data used to mint in Nonfungible collection.77		NotNonfungibleDataUsedToMintFungibleCollectionToken,78		/// Used amount > 1 with NFT79		NonfungibleItemsHaveNoAmount,80		/// Unable to burn NFT with children81		CantBurnNftWithChildren,82		/// Unable to burn a collection containing NFTs that have children83		CantBurnCollectionWithNestedTokens84	}8586	#[pallet::config]87	pub trait Config:88		frame_system::Config + pallet_common::Config + pallet_structure::Config + pallet_evm::Config89	{90		type WeightInfo: WeightInfo;91	}9293	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);9495	#[pallet::pallet]96	#[pallet::storage_version(STORAGE_VERSION)]97	#[pallet::generate_store(pub(super) trait Store)]98	pub struct Pallet<T>(_);99100	#[pallet::storage]101	pub type TokensMinted<T: Config> =102		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;103	#[pallet::storage]104	pub type TokensBurnt<T: Config> =105		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;106107	#[pallet::storage]108	pub type TokenData<T: Config> = StorageNMap<109		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),110		Value = ItemData<T::CrossAccountId>,111		QueryKind = OptionQuery,112	>;113114	#[pallet::storage]115	#[pallet::getter(fn token_properties)]116	pub type TokenProperties<T: Config> = StorageNMap<117		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),118		Value = Properties,119		QueryKind = ValueQuery,120		OnEmpty = up_data_structs::TokenProperties,121	>;122123	/// Used to enumerate tokens owned by account124	#[pallet::storage]125	pub type Owned<T: Config> = StorageNMap<126		Key = (127			Key<Twox64Concat, CollectionId>,128			Key<Blake2_128Concat, T::CrossAccountId>,129			Key<Twox64Concat, TokenId>,130		),131		Value = bool,132		QueryKind = ValueQuery,133	>;134135	/// Used to enumerate token's children136	#[pallet::storage]137	#[pallet::getter(fn token_children)]138	pub type TokenChildren<T: Config> = StorageNMap<139		Key = (140			Key<Twox64Concat, CollectionId>,141			Key<Twox64Concat, TokenId>,142			Key<Twox64Concat, (CollectionId, TokenId)>,143		),144		Value = bool,145		QueryKind = ValueQuery,146	>;147148	#[pallet::storage]149	pub type AccountBalance<T: Config> = StorageNMap<150		Key = (151			Key<Twox64Concat, CollectionId>,152			Key<Blake2_128Concat, T::CrossAccountId>,153		),154		Value = u32,155		QueryKind = ValueQuery,156	>;157158	#[pallet::storage]159	pub type Allowance<T: Config> = StorageNMap<160		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),161		Value = T::CrossAccountId,162		QueryKind = OptionQuery,163	>;164165	#[pallet::hooks]166	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {167		fn on_runtime_upgrade() -> Weight {168			if StorageVersion::get::<Pallet<T>>() < StorageVersion::new(1) {169				let mut had_consts = BTreeSet::new();170				<TokenData<T>>::translate::<ItemDataVersion1<T::CrossAccountId>, _>(|(collection, token), v| {171					let mut props = vec![];172					if !v.const_data.is_empty() {173						props.push(Property {174							key: b"_old_constData".to_vec().try_into().unwrap(),175							value: v.const_data.clone().into_inner().try_into().expect("const too long"),176						});177						had_consts.insert(collection);178					}179					if !v.variable_data.is_empty() {180						props.push(Property {181							key: b"_old_variableData".to_vec().try_into().unwrap(),182							value: v.variable_data.clone().into_inner().try_into().expect("variable too long"),183						})184					}185					if !props.is_empty() {186						Self::set_scoped_token_properties(187							collection,188							token,189							PropertyScope::None,190							props.into_iter(),191						).expect("existing token data exceeds property storage");192					}193					Some(<ItemDataVersion2<T::CrossAccountId>>::from(v))194				});195				for collection in had_consts {196					<PalletCommon<T>>::set_property_permission_unchecked(197						collection,198						PropertyKeyPermission {199							key: b"_old_constData".to_vec().try_into().unwrap(),200							permission: PropertyPermission {201								mutable: false,202								collection_admin: true,203								token_owner: false,204							},205						}206					).expect("failed to configure permission");207				}208			}209210			0211		}212	}213}214215pub struct NonfungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);216impl<T: Config> NonfungibleHandle<T> {217	pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {218		Self(inner)219	}220	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {221		self.0222	}223	pub fn common_mut(&mut self) -> &mut pallet_common::CollectionHandle<T> {224		&mut self.0225	}226}227impl<T: Config> WithRecorder<T> for NonfungibleHandle<T> {228	fn recorder(&self) -> &SubstrateRecorder<T> {229		self.0.recorder()230	}231	fn into_recorder(self) -> SubstrateRecorder<T> {232		self.0.into_recorder()233	}234}235impl<T: Config> Deref for NonfungibleHandle<T> {236	type Target = pallet_common::CollectionHandle<T>;237238	fn deref(&self) -> &Self::Target {239		&self.0240	}241}242243impl<T: Config> Pallet<T> {244	pub fn total_supply(collection: &NonfungibleHandle<T>) -> u32 {245		<TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)246	}247	pub fn token_exists(collection: &NonfungibleHandle<T>, token: TokenId) -> bool {248		<TokenData<T>>::contains_key((collection.id, token))249	}250251	pub fn set_scoped_token_property(252		collection_id: CollectionId,253		token_id: TokenId,254		scope: PropertyScope,255		property: Property,256	) -> DispatchResult {257		TokenProperties::<T>::try_mutate((collection_id, token_id), |properties| {258			properties.try_scoped_set(scope, property.key, property.value)259		})260		.map_err(<CommonError<T>>::from)?;261262		Ok(())263	}264265	pub fn set_scoped_token_properties(266		collection_id: CollectionId,267		token_id: TokenId,268		scope: PropertyScope,269		properties: impl Iterator<Item=Property>,270	) -> DispatchResult {271		TokenProperties::<T>::try_mutate((collection_id, token_id), |stored_properties| {272			stored_properties.try_scoped_set_from_iter(scope, properties)273		})274		.map_err(<CommonError<T>>::from)?;275276		Ok(())277	}278279	pub fn current_token_id(collection_id: CollectionId) -> TokenId {280		TokenId(<TokensMinted<T>>::get(collection_id))281	}282}283284// unchecked calls skips any permission checks285impl<T: Config> Pallet<T> {286	pub fn init_collection(287		owner: T::AccountId,288		data: CreateCollectionData<T::AccountId>,289	) -> Result<CollectionId, DispatchError> {290		<PalletCommon<T>>::init_collection(owner, data)291	}292	pub fn destroy_collection(293		collection: NonfungibleHandle<T>,294		sender: &T::CrossAccountId,295	) -> DispatchResult {296		let id = collection.id;297298		if Self::collection_has_nested_tokens(id) {299			return Err(<Error<T>>::CantBurnCollectionWithNestedTokens.into());300		}301302		// =========303304		PalletCommon::destroy_collection(collection.0, sender)?;305306		<TokenData<T>>::remove_prefix((id,), None);307		<TokenChildren<T>>::remove_prefix((id,), None);308		<Owned<T>>::remove_prefix((id,), None);309		<TokensMinted<T>>::remove(id);310		<TokensBurnt<T>>::remove(id);311		<Allowance<T>>::remove_prefix((id,), None);312		<AccountBalance<T>>::remove_prefix((id,), None);313		Ok(())314	}315316	pub fn burn(317		collection: &NonfungibleHandle<T>,318		sender: &T::CrossAccountId,319		token: TokenId,320	) -> DispatchResult {321		let token_data =322			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;323		ensure!(324			&token_data.owner == sender325				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(sender)),326			<CommonError<T>>::NoPermission327		);328329		if collection.permissions.access() == AccessMode::AllowList {330			collection.check_allowlist(sender)?;331		}332333		if Self::token_has_children(collection.id, token) {334			return Err(<Error<T>>::CantBurnNftWithChildren.into());335		}336337		let burnt = <TokensBurnt<T>>::get(collection.id)338			.checked_add(1)339			.ok_or(ArithmeticError::Overflow)?;340341		let balance = <AccountBalance<T>>::get((collection.id, token_data.owner.clone()))342			.checked_sub(1)343			.ok_or(ArithmeticError::Overflow)?;344345		if balance == 0 {346			<AccountBalance<T>>::remove((collection.id, token_data.owner.clone()));347		} else {348			<AccountBalance<T>>::insert((collection.id, token_data.owner.clone()), balance);349		}350351		if let Some(owner) = T::CrossTokenAddressMapping::address_to_token(&token_data.owner) {352			Self::unnest(owner, (collection.id, token));353		}354355		// =========356357		<Owned<T>>::remove((collection.id, &token_data.owner, token));358		<TokensBurnt<T>>::insert(collection.id, burnt);359		<TokenData<T>>::remove((collection.id, token));360		<TokenProperties<T>>::remove((collection.id, token));361		let old_spender = <Allowance<T>>::take((collection.id, token));362363		if let Some(old_spender) = old_spender {364			<PalletCommon<T>>::deposit_event(CommonEvent::Approved(365				collection.id,366				token,367				sender.clone(),368				old_spender,369				0,370			));371		}372373		<PalletEvm<T>>::deposit_log(374			ERC721Events::Transfer {375				from: *token_data.owner.as_eth(),376				to: H160::default(),377				token_id: token.into(),378			}379			.to_log(collection_id_to_address(collection.id)),380		);381		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(382			collection.id,383			token,384			token_data.owner,385			1,386		));387		Ok(())388	}389390	pub fn set_token_property(391		collection: &NonfungibleHandle<T>,392		sender: &T::CrossAccountId,393		token_id: TokenId,394		property: Property,395	) -> DispatchResult {396		Self::check_token_change_permission(collection, sender, token_id, &property.key)?;397398		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {399			let property = property.clone();400			properties.try_set(property.key, property.value)401		})402		.map_err(<CommonError<T>>::from)?;403404		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertySet(405			collection.id,406			token_id,407			property.key,408		));409410		Ok(())411	}412413	#[transactional]414	pub fn set_token_properties(415		collection: &NonfungibleHandle<T>,416		sender: &T::CrossAccountId,417		token_id: TokenId,418		properties: Vec<Property>,419	) -> DispatchResult {420		for property in properties {421			Self::set_token_property(collection, sender, token_id, property)?;422		}423424		Ok(())425	}426427	pub fn delete_token_property(428		collection: &NonfungibleHandle<T>,429		sender: &T::CrossAccountId,430		token_id: TokenId,431		property_key: PropertyKey,432	) -> DispatchResult {433		Self::check_token_change_permission(collection, sender, token_id, &property_key)?;434435		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {436			properties.remove(&property_key)437		})438		.map_err(<CommonError<T>>::from)?;439440		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertyDeleted(441			collection.id,442			token_id,443			property_key,444		));445446		Ok(())447	}448449	fn check_token_change_permission(450		collection: &NonfungibleHandle<T>,451		sender: &T::CrossAccountId,452		token_id: TokenId,453		property_key: &PropertyKey,454	) -> DispatchResult {455		let permission = <PalletCommon<T>>::property_permissions(collection.id)456			.get(property_key)457			.cloned()458			.unwrap_or_else(PropertyPermission::none);459460		let token_data = <TokenData<T>>::get((collection.id, token_id))461			.ok_or(<CommonError<T>>::TokenNotFound)?;462463		let check_token_owner = || -> DispatchResult {464			ensure!(&token_data.owner == sender, <CommonError<T>>::NoPermission);465			Ok(())466		};467468		let is_property_exists = TokenProperties::<T>::get((collection.id, token_id))469			.get(property_key)470			.is_some();471472		match permission {473			PropertyPermission { mutable: false, .. } if is_property_exists => {474				Err(<CommonError<T>>::NoPermission.into())475			}476477			PropertyPermission {478				collection_admin,479				token_owner,480				..481			} => {482				let mut check_result = Err(<CommonError<T>>::NoPermission.into());483484				if collection_admin {485					check_result = collection.check_is_owner_or_admin(sender);486				}487488				if token_owner {489					check_result.or_else(|_| check_token_owner())490				} else {491					check_result492				}493			}494		}495	}496497	#[transactional]498	pub fn delete_token_properties(499		collection: &NonfungibleHandle<T>,500		sender: &T::CrossAccountId,501		token_id: TokenId,502		property_keys: Vec<PropertyKey>,503	) -> DispatchResult {504		for key in property_keys {505			Self::delete_token_property(collection, sender, token_id, key)?;506		}507508		Ok(())509	}510511	pub fn set_collection_properties(512		collection: &NonfungibleHandle<T>,513		sender: &T::CrossAccountId,514		properties: Vec<Property>,515	) -> DispatchResult {516		<PalletCommon<T>>::set_collection_properties(collection, sender, properties)517	}518519	pub fn delete_collection_properties(520		collection: &CollectionHandle<T>,521		sender: &T::CrossAccountId,522		property_keys: Vec<PropertyKey>,523	) -> DispatchResult {524		<PalletCommon<T>>::delete_collection_properties(collection, sender, property_keys)525	}526527	pub fn set_property_permissions(528		collection: &CollectionHandle<T>,529		sender: &T::CrossAccountId,530		property_permissions: Vec<PropertyKeyPermission>,531	) -> DispatchResult {532		<PalletCommon<T>>::set_property_permissions(collection, sender, property_permissions)533	}534535	pub fn set_property_permission(536		collection: &CollectionHandle<T>,537		sender: &T::CrossAccountId,538		permission: PropertyKeyPermission,539	) -> DispatchResult {540		<PalletCommon<T>>::set_property_permission(collection, sender, permission)541	}542543	pub fn transfer(544		collection: &NonfungibleHandle<T>,545		from: &T::CrossAccountId,546		to: &T::CrossAccountId,547		token: TokenId,548		nesting_budget: &dyn Budget,549	) -> DispatchResult {550		ensure!(551			collection.limits.transfers_enabled(),552			<CommonError<T>>::TransferNotAllowed553		);554555		let token_data =556			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;557		// TODO: require sender to be token, owner, require admins to go through transfer_from558		ensure!(559			&token_data.owner == from560				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(from)),561			<CommonError<T>>::NoPermission562		);563564		if collection.permissions.access() == AccessMode::AllowList {565			collection.check_allowlist(from)?;566			collection.check_allowlist(to)?;567		}568		<PalletCommon<T>>::ensure_correct_receiver(to)?;569570		let balance_from = <AccountBalance<T>>::get((collection.id, from))571			.checked_sub(1)572			.ok_or(<CommonError<T>>::TokenValueTooLow)?;573		let balance_to = if from != to {574			let balance_to = <AccountBalance<T>>::get((collection.id, to))575				.checked_add(1)576				.ok_or(ArithmeticError::Overflow)?;577578			ensure!(579				balance_to < collection.limits.account_token_ownership_limit(),580				<CommonError<T>>::AccountTokenLimitExceeded,581			);582583			Some(balance_to)584		} else {585			None586		};587588		<PalletStructure<T>>::nest_if_sent_to_token(589			from.clone(),590			to,591			collection.id,592			token,593			nesting_budget594		)?;595596		// =========597598		<TokenData<T>>::insert(599			(collection.id, token),600			ItemData {601				owner: to.clone(),602				..token_data603			},604		);605606		if let Some(balance_to) = balance_to {607			// from != to608			if balance_from == 0 {609				<AccountBalance<T>>::remove((collection.id, from));610			} else {611				<AccountBalance<T>>::insert((collection.id, from), balance_from);612			}613			<AccountBalance<T>>::insert((collection.id, to), balance_to);614			<Owned<T>>::remove((collection.id, from, token));615			<Owned<T>>::insert((collection.id, to, token), true);616		}617		Self::set_allowance_unchecked(collection, from, token, None, true);618619		<PalletEvm<T>>::deposit_log(620			ERC721Events::Transfer {621				from: *from.as_eth(),622				to: *to.as_eth(),623				token_id: token.into(),624			}625			.to_log(collection_id_to_address(collection.id)),626		);627		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(628			collection.id,629			token,630			from.clone(),631			to.clone(),632			1,633		));634		Ok(())635	}636637	pub fn create_multiple_items(638		collection: &NonfungibleHandle<T>,639		sender: &T::CrossAccountId,640		data: Vec<CreateItemData<T>>,641		nesting_budget: &dyn Budget,642	) -> DispatchResult {643		if !collection.is_owner_or_admin(sender) {644			ensure!(645				collection.permissions.mint_mode(),646				<CommonError<T>>::PublicMintingNotAllowed647			);648			collection.check_allowlist(sender)?;649650			for item in data.iter() {651				collection.check_allowlist(&item.owner)?;652			}653		}654655		for data in data.iter() {656			<PalletCommon<T>>::ensure_correct_receiver(&data.owner)?;657		}658659		let first_token = <TokensMinted<T>>::get(collection.id);660		let tokens_minted = first_token661			.checked_add(data.len() as u32)662			.ok_or(ArithmeticError::Overflow)?;663		ensure!(664			tokens_minted <= collection.limits.token_limit(),665			<CommonError<T>>::CollectionTokenLimitExceeded666		);667668		let mut balances = BTreeMap::new();669		for data in &data {670			let balance = balances671				.entry(&data.owner)672				.or_insert_with(|| <AccountBalance<T>>::get((collection.id, &data.owner)));673			*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;674675			ensure!(676				*balance <= collection.limits.account_token_ownership_limit(),677				<CommonError<T>>::AccountTokenLimitExceeded,678			);679		}680681		for (i, data) in data.iter().enumerate() {682			let token = TokenId(first_token + i as u32 + 1);683684			<PalletStructure<T>>::check_nesting(685				sender.clone(),686				&data.owner,687				collection.id,688				token,689				nesting_budget,690			)?;691		}692693		// =========694695		with_transaction(|| {696			for (i, data) in data.iter().enumerate() {697				let token = first_token + i as u32 + 1;698699				<TokenData<T>>::insert(700					(collection.id, token),701					ItemData {702						// const_data: data.const_data.clone(),703						owner: data.owner.clone(),704					},705				);706707				<PalletStructure<T>>::nest_if_sent_to_token_unchecked(&data.owner, collection.id, TokenId(token));708709				if let Err(e) = Self::set_token_properties(710					collection,711					sender,712					TokenId(token),713					data.properties.clone().into_inner(),714				) {715					return TransactionOutcome::Rollback(Err(e));716				}717			}718			TransactionOutcome::Commit(Ok(()))719		})?;720721		<TokensMinted<T>>::insert(collection.id, tokens_minted);722		for (account, balance) in balances {723			<AccountBalance<T>>::insert((collection.id, account), balance);724		}725		for (i, data) in data.into_iter().enumerate() {726			let token = first_token + i as u32 + 1;727			<Owned<T>>::insert((collection.id, &data.owner, token), true);728729			<PalletEvm<T>>::deposit_log(730				ERC721Events::Transfer {731					from: H160::default(),732					to: *data.owner.as_eth(),733					token_id: token.into(),734				}735				.to_log(collection_id_to_address(collection.id)),736			);737			<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(738				collection.id,739				TokenId(token),740				data.owner.clone(),741				1,742			));743		}744		Ok(())745	}746747	pub fn set_allowance_unchecked(748		collection: &NonfungibleHandle<T>,749		sender: &T::CrossAccountId,750		token: TokenId,751		spender: Option<&T::CrossAccountId>,752		assume_implicit_eth: bool,753	) {754		if let Some(spender) = spender {755			let old_spender = <Allowance<T>>::get((collection.id, token));756			<Allowance<T>>::insert((collection.id, token), spender);757			// In ERC721 there is only one possible approved user of token, so we set758			// approved user to spender759			<PalletEvm<T>>::deposit_log(760				ERC721Events::Approval {761					owner: *sender.as_eth(),762					approved: *spender.as_eth(),763					token_id: token.into(),764				}765				.to_log(collection_id_to_address(collection.id)),766			);767			// In Unique chain, any token can have any amount of approved users, so we need to768			// set allowance of old owner to 0, and allowance of new owner to 1769			if old_spender.as_ref() != Some(spender) {770				if let Some(old_owner) = old_spender {771					<PalletCommon<T>>::deposit_event(CommonEvent::Approved(772						collection.id,773						token,774						sender.clone(),775						old_owner,776						0,777					));778				}779				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(780					collection.id,781					token,782					sender.clone(),783					spender.clone(),784					1,785				));786			}787		} else {788			let old_spender = <Allowance<T>>::take((collection.id, token));789			if !assume_implicit_eth {790				// In ERC721 there is only one possible approved user of token, so we set791				// approved user to zero address792				<PalletEvm<T>>::deposit_log(793					ERC721Events::Approval {794						owner: *sender.as_eth(),795						approved: H160::default(),796						token_id: token.into(),797					}798					.to_log(collection_id_to_address(collection.id)),799				);800			}801			// In Unique chain, any token can have any amount of approved users, so we need to802			// set allowance of old owner to 0803			if let Some(old_spender) = old_spender {804				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(805					collection.id,806					token,807					sender.clone(),808					old_spender,809					0,810				));811			}812		}813	}814815	pub fn set_allowance(816		collection: &NonfungibleHandle<T>,817		sender: &T::CrossAccountId,818		token: TokenId,819		spender: Option<&T::CrossAccountId>,820	) -> DispatchResult {821		if collection.permissions.access() == AccessMode::AllowList {822			collection.check_allowlist(sender)?;823			if let Some(spender) = spender {824				collection.check_allowlist(spender)?;825			}826		}827828		if let Some(spender) = spender {829			<PalletCommon<T>>::ensure_correct_receiver(spender)?;830		}831		let token_data =832			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;833		if &token_data.owner != sender {834			ensure!(835				collection.ignores_owned_amount(sender),836				<CommonError<T>>::CantApproveMoreThanOwned837			);838		}839840		// =========841842		Self::set_allowance_unchecked(collection, sender, token, spender, false);843		Ok(())844	}845846	fn check_allowed(847		collection: &NonfungibleHandle<T>,848		spender: &T::CrossAccountId,849		from: &T::CrossAccountId,850		token: TokenId,851		nesting_budget: &dyn Budget,852	) -> DispatchResult {853		if spender.conv_eq(from) {854			return Ok(());855		}856		if collection.permissions.access() == AccessMode::AllowList {857			// `from`, `to` checked in [`transfer`]858			collection.check_allowlist(spender)?;859		}860		if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {861			// TODO: should collection owner be allowed to perform this transfer?862			ensure!(863				<PalletStructure<T>>::check_indirectly_owned(864					spender.clone(),865					source.0,866					source.1,867					None,868					nesting_budget869				)?,870				<CommonError<T>>::ApprovedValueTooLow,871			);872			return Ok(());873		}874		if <Allowance<T>>::get((collection.id, token)).as_ref() == Some(spender) {875			return Ok(());876		}877		ensure!(878			collection.ignores_allowance(spender),879			<CommonError<T>>::ApprovedValueTooLow880		);881		Ok(())882	}883884	pub fn transfer_from(885		collection: &NonfungibleHandle<T>,886		spender: &T::CrossAccountId,887		from: &T::CrossAccountId,888		to: &T::CrossAccountId,889		token: TokenId,890		nesting_budget: &dyn Budget,891	) -> DispatchResult {892		Self::check_allowed(collection, spender, from, token, nesting_budget)?;893894		// =========895896		// Allowance is reset in [`transfer`]897		Self::transfer(collection, from, to, token, nesting_budget)898	}899900	pub fn burn_from(901		collection: &NonfungibleHandle<T>,902		spender: &T::CrossAccountId,903		from: &T::CrossAccountId,904		token: TokenId,905		nesting_budget: &dyn Budget,906	) -> DispatchResult {907		Self::check_allowed(collection, spender, from, token, nesting_budget)?;908909		// =========910911		Self::burn(collection, from, token)912	}913914	pub fn check_nesting(915		handle: &NonfungibleHandle<T>,916		sender: T::CrossAccountId,917		from: (CollectionId, TokenId),918		under: TokenId,919		nesting_budget: &dyn Budget,920	) -> DispatchResult {921		fn ensure_sender_allowed<T: Config>(922			collection: CollectionId,923			token: TokenId,924			for_nest: (CollectionId, TokenId),925			sender: T::CrossAccountId,926			budget: &dyn Budget,927		) -> DispatchResult {928			ensure!(929				<PalletStructure<T>>::check_indirectly_owned(930					sender,931					collection,932					token,933					Some(for_nest),934					budget935				)?,936				<CommonError<T>>::OnlyOwnerAllowedToNest,937			);938			Ok(())939		}940		match handle.permissions.nesting() {941			NestingRule::Disabled => fail!(<CommonError<T>>::NestingIsDisabled),942			NestingRule::Owner => {943				ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?944			}945			NestingRule::OwnerRestricted(whitelist) => {946				ensure!(947					whitelist.contains(&from.0),948					<CommonError<T>>::SourceCollectionIsNotAllowedToNest949				);950				ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?951			}952		}953		Ok(())954	}955956	fn nest(957		under: (CollectionId, TokenId),958		to_nest: (CollectionId, TokenId),959	) {960		<TokenChildren<T>>::insert(961			(under.0, under.1, (to_nest.0, to_nest.1)),962			true963		);964	}965966	fn unnest(967		under: (CollectionId, TokenId),968		to_unnest: (CollectionId, TokenId),969	) {970		<TokenChildren<T>>::remove(971			(under.0, under.1, to_unnest)972		);973	}974975	fn collection_has_nested_tokens(collection_id: CollectionId) -> bool {976		<TokenChildren<T>>::iter_prefix((collection_id,)).next().is_some()977	}978979	fn token_has_children(collection_id: CollectionId, token_id: TokenId) -> bool {980		<TokenChildren<T>>::iter_prefix((collection_id, token_id)).next().is_some()981	}982983	/// Delegated to `create_multiple_items`984	pub fn create_item(985		collection: &NonfungibleHandle<T>,986		sender: &T::CrossAccountId,987		data: CreateItemData<T>,988		nesting_budget: &dyn Budget,989	) -> DispatchResult {990		Self::create_multiple_items(collection, sender, vec![data], nesting_budget)991	}992}