git.delta.rocks / unique-network / refs/commits / 415353264b69

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>, _>(|(collection, token), v| {168					let mut props = vec![];169					if !v.const_data.is_empty() {170						props.push(Property {171							key: b"_old_constData".to_vec().try_into().unwrap(),172							value: v.const_data.clone().into_inner().try_into().expect("const too long"),173						});174						had_consts.insert(collection);175					}176					if !v.variable_data.is_empty() {177						props.push(Property {178							key: b"_old_variableData".to_vec().try_into().unwrap(),179							value: v.variable_data.clone().into_inner().try_into().expect("variable too long"),180						})181					}182					if !props.is_empty() {183						Self::set_scoped_token_properties(184							collection,185							token,186							PropertyScope::None,187							props.into_iter(),188						).expect("existing token data exceeds property storage");189					}190					Some(<ItemDataVersion2<T::CrossAccountId>>::from(v))191				});192				for collection in had_consts {193					<PalletCommon<T>>::set_property_permission_unchecked(194						collection,195						PropertyKeyPermission {196							key: b"_old_constData".to_vec().try_into().unwrap(),197							permission: PropertyPermission {198								mutable: false,199								collection_admin: true,200								token_owner: false,201							},202						}203					).expect("failed to configure permission");204				}205			}206207			0208		}209	}210}211212pub struct NonfungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);213impl<T: Config> NonfungibleHandle<T> {214	pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {215		Self(inner)216	}217	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {218		self.0219	}220	pub fn common_mut(&mut self) -> &mut pallet_common::CollectionHandle<T> {221		&mut self.0222	}223}224impl<T: Config> WithRecorder<T> for NonfungibleHandle<T> {225	fn recorder(&self) -> &SubstrateRecorder<T> {226		self.0.recorder()227	}228	fn into_recorder(self) -> SubstrateRecorder<T> {229		self.0.into_recorder()230	}231}232impl<T: Config> Deref for NonfungibleHandle<T> {233	type Target = pallet_common::CollectionHandle<T>;234235	fn deref(&self) -> &Self::Target {236		&self.0237	}238}239240impl<T: Config> Pallet<T> {241	pub fn total_supply(collection: &NonfungibleHandle<T>) -> u32 {242		<TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)243	}244	pub fn token_exists(collection: &NonfungibleHandle<T>, token: TokenId) -> bool {245		<TokenData<T>>::contains_key((collection.id, token))246	}247248	pub fn set_scoped_token_property(249		collection_id: CollectionId,250		token_id: TokenId,251		scope: PropertyScope,252		property: Property,253	) -> DispatchResult {254		TokenProperties::<T>::try_mutate((collection_id, token_id), |properties| {255			properties.try_scoped_set(scope, property.key, property.value)256		})257		.map_err(<CommonError<T>>::from)?;258259		Ok(())260	}261262	pub fn set_scoped_token_properties(263		collection_id: CollectionId,264		token_id: TokenId,265		scope: PropertyScope,266		properties: impl Iterator<Item=Property>,267	) -> DispatchResult {268		TokenProperties::<T>::try_mutate((collection_id, token_id), |stored_properties| {269			stored_properties.try_scoped_set_from_iter(scope, properties)270		})271		.map_err(<CommonError<T>>::from)?;272273		Ok(())274	}275276	pub fn current_token_id(collection_id: CollectionId) -> TokenId {277		TokenId(<TokensMinted<T>>::get(collection_id))278	}279}280281// unchecked calls skips any permission checks282impl<T: Config> Pallet<T> {283	pub fn init_collection(284		owner: T::AccountId,285		data: CreateCollectionData<T::AccountId>,286	) -> Result<CollectionId, DispatchError> {287		<PalletCommon<T>>::init_collection(owner, data)288	}289	pub fn destroy_collection(290		collection: NonfungibleHandle<T>,291		sender: &T::CrossAccountId,292	) -> DispatchResult {293		let id = collection.id;294295		if Self::collection_has_tokens(id) {296			return Err(<CommonError<T>>::CantDestroyNotEmptyCollection.into());297		}298299		// =========300301		PalletCommon::destroy_collection(collection.0, sender)?;302303		<TokenData<T>>::remove_prefix((id,), None);304		<TokenChildren<T>>::remove_prefix((id,), None);305		<Owned<T>>::remove_prefix((id,), None);306		<TokensMinted<T>>::remove(id);307		<TokensBurnt<T>>::remove(id);308		<Allowance<T>>::remove_prefix((id,), None);309		<AccountBalance<T>>::remove_prefix((id,), None);310		Ok(())311	}312313	pub fn burn(314		collection: &NonfungibleHandle<T>,315		sender: &T::CrossAccountId,316		token: TokenId,317	) -> DispatchResult {318		let token_data =319			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;320		ensure!(321			&token_data.owner == sender322				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(sender)),323			<CommonError<T>>::NoPermission324		);325326		if collection.permissions.access() == AccessMode::AllowList {327			collection.check_allowlist(sender)?;328		}329330		if Self::token_has_children(collection.id, token) {331			return Err(<Error<T>>::CantBurnNftWithChildren.into());332		}333334		let burnt = <TokensBurnt<T>>::get(collection.id)335			.checked_add(1)336			.ok_or(ArithmeticError::Overflow)?;337338		let balance = <AccountBalance<T>>::get((collection.id, token_data.owner.clone()))339			.checked_sub(1)340			.ok_or(ArithmeticError::Overflow)?;341342		// =========343344		if balance == 0 {345			<AccountBalance<T>>::remove((collection.id, token_data.owner.clone()));346		} else {347			<AccountBalance<T>>::insert((collection.id, token_data.owner.clone()), balance);348		}349350		<PalletStructure<T>>::unnest_if_nested(351			&token_data.owner,352			collection.id,353			token354		);355356		<Owned<T>>::remove((collection.id, &token_data.owner, token));357		<TokensBurnt<T>>::insert(collection.id, burnt);358		<TokenData<T>>::remove((collection.id, token));359		<TokenProperties<T>>::remove((collection.id, token));360		let old_spender = <Allowance<T>>::take((collection.id, token));361362		if let Some(old_spender) = old_spender {363			<PalletCommon<T>>::deposit_event(CommonEvent::Approved(364				collection.id,365				token,366				sender.clone(),367				old_spender,368				0,369			));370		}371372		<PalletEvm<T>>::deposit_log(373			ERC721Events::Transfer {374				from: *token_data.owner.as_eth(),375				to: H160::default(),376				token_id: token.into(),377			}378			.to_log(collection_id_to_address(collection.id)),379		);380		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(381			collection.id,382			token,383			token_data.owner,384			1,385		));386		Ok(())387	}388389	pub fn set_token_property(390		collection: &NonfungibleHandle<T>,391		sender: &T::CrossAccountId,392		token_id: TokenId,393		property: Property,394	) -> DispatchResult {395		Self::check_token_change_permission(collection, sender, token_id, &property.key)?;396397		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {398			let property = property.clone();399			properties.try_set(property.key, property.value)400		})401		.map_err(<CommonError<T>>::from)?;402403		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertySet(404			collection.id,405			token_id,406			property.key,407		));408409		Ok(())410	}411412	#[transactional]413	pub fn set_token_properties(414		collection: &NonfungibleHandle<T>,415		sender: &T::CrossAccountId,416		token_id: TokenId,417		properties: Vec<Property>,418	) -> DispatchResult {419		for property in properties {420			Self::set_token_property(collection, sender, token_id, property)?;421		}422423		Ok(())424	}425426	pub fn delete_token_property(427		collection: &NonfungibleHandle<T>,428		sender: &T::CrossAccountId,429		token_id: TokenId,430		property_key: PropertyKey,431	) -> DispatchResult {432		Self::check_token_change_permission(collection, sender, token_id, &property_key)?;433434		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {435			properties.remove(&property_key)436		})437		.map_err(<CommonError<T>>::from)?;438439		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertyDeleted(440			collection.id,441			token_id,442			property_key,443		));444445		Ok(())446	}447448	fn check_token_change_permission(449		collection: &NonfungibleHandle<T>,450		sender: &T::CrossAccountId,451		token_id: TokenId,452		property_key: &PropertyKey,453	) -> DispatchResult {454		let permission = <PalletCommon<T>>::property_permissions(collection.id)455			.get(property_key)456			.cloned()457			.unwrap_or_else(PropertyPermission::none);458459		let token_data = <TokenData<T>>::get((collection.id, token_id))460			.ok_or(<CommonError<T>>::TokenNotFound)?;461462		let check_token_owner = || -> DispatchResult {463			ensure!(&token_data.owner == sender, <CommonError<T>>::NoPermission);464			Ok(())465		};466467		let is_property_exists = TokenProperties::<T>::get((collection.id, token_id))468			.get(property_key)469			.is_some();470471		match permission {472			PropertyPermission { mutable: false, .. } if is_property_exists => {473				Err(<CommonError<T>>::NoPermission.into())474			}475476			PropertyPermission {477				collection_admin,478				token_owner,479				..480			} => {481				let mut check_result = Err(<CommonError<T>>::NoPermission.into());482483				if collection_admin {484					check_result = collection.check_is_owner_or_admin(sender);485				}486487				if token_owner {488					check_result.or_else(|_| check_token_owner())489				} else {490					check_result491				}492			}493		}494	}495496	#[transactional]497	pub fn delete_token_properties(498		collection: &NonfungibleHandle<T>,499		sender: &T::CrossAccountId,500		token_id: TokenId,501		property_keys: Vec<PropertyKey>,502	) -> DispatchResult {503		for key in property_keys {504			Self::delete_token_property(collection, sender, token_id, key)?;505		}506507		Ok(())508	}509510	pub fn set_collection_properties(511		collection: &NonfungibleHandle<T>,512		sender: &T::CrossAccountId,513		properties: Vec<Property>,514	) -> DispatchResult {515		<PalletCommon<T>>::set_collection_properties(collection, sender, properties)516	}517518	pub fn delete_collection_properties(519		collection: &CollectionHandle<T>,520		sender: &T::CrossAccountId,521		property_keys: Vec<PropertyKey>,522	) -> DispatchResult {523		<PalletCommon<T>>::delete_collection_properties(collection, sender, property_keys)524	}525526	pub fn set_property_permissions(527		collection: &CollectionHandle<T>,528		sender: &T::CrossAccountId,529		property_permissions: Vec<PropertyKeyPermission>,530	) -> DispatchResult {531		<PalletCommon<T>>::set_property_permissions(collection, sender, property_permissions)532	}533534	pub fn set_property_permission(535		collection: &CollectionHandle<T>,536		sender: &T::CrossAccountId,537		permission: PropertyKeyPermission,538	) -> DispatchResult {539		<PalletCommon<T>>::set_property_permission(collection, sender, permission)540	}541542	pub fn transfer(543		collection: &NonfungibleHandle<T>,544		from: &T::CrossAccountId,545		to: &T::CrossAccountId,546		token: TokenId,547		nesting_budget: &dyn Budget,548	) -> DispatchResult {549		ensure!(550			collection.limits.transfers_enabled(),551			<CommonError<T>>::TransferNotAllowed552		);553554		let token_data =555			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;556		// TODO: require sender to be token, owner, require admins to go through transfer_from557		ensure!(558			&token_data.owner == from559				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(from)),560			<CommonError<T>>::NoPermission561		);562563		if collection.permissions.access() == AccessMode::AllowList {564			collection.check_allowlist(from)?;565			collection.check_allowlist(to)?;566		}567		<PalletCommon<T>>::ensure_correct_receiver(to)?;568569		let balance_from = <AccountBalance<T>>::get((collection.id, from))570			.checked_sub(1)571			.ok_or(<CommonError<T>>::TokenValueTooLow)?;572		let balance_to = if from != to {573			let balance_to = <AccountBalance<T>>::get((collection.id, to))574				.checked_add(1)575				.ok_or(ArithmeticError::Overflow)?;576577			ensure!(578				balance_to < collection.limits.account_token_ownership_limit(),579				<CommonError<T>>::AccountTokenLimitExceeded,580			);581582			Some(balance_to)583		} else {584			None585		};586587		<PalletStructure<T>>::nest_if_sent_to_token(588			from.clone(),589			to,590			collection.id,591			token,592			nesting_budget593		)?;594595		// =========596597		<PalletStructure<T>>::unnest_if_nested(598			from,599			collection.id,600			token601		);602603		<TokenData<T>>::insert(604			(collection.id, token),605			ItemData {606				owner: to.clone(),607				..token_data608			},609		);610611		if let Some(balance_to) = balance_to {612			// from != to613			if balance_from == 0 {614				<AccountBalance<T>>::remove((collection.id, from));615			} else {616				<AccountBalance<T>>::insert((collection.id, from), balance_from);617			}618			<AccountBalance<T>>::insert((collection.id, to), balance_to);619			<Owned<T>>::remove((collection.id, from, token));620			<Owned<T>>::insert((collection.id, to, token), true);621		}622		Self::set_allowance_unchecked(collection, from, token, None, true);623624		<PalletEvm<T>>::deposit_log(625			ERC721Events::Transfer {626				from: *from.as_eth(),627				to: *to.as_eth(),628				token_id: token.into(),629			}630			.to_log(collection_id_to_address(collection.id)),631		);632		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(633			collection.id,634			token,635			from.clone(),636			to.clone(),637			1,638		));639		Ok(())640	}641642	pub fn create_multiple_items(643		collection: &NonfungibleHandle<T>,644		sender: &T::CrossAccountId,645		data: Vec<CreateItemData<T>>,646		nesting_budget: &dyn Budget,647	) -> DispatchResult {648		if !collection.is_owner_or_admin(sender) {649			ensure!(650				collection.permissions.mint_mode(),651				<CommonError<T>>::PublicMintingNotAllowed652			);653			collection.check_allowlist(sender)?;654655			for item in data.iter() {656				collection.check_allowlist(&item.owner)?;657			}658		}659660		for data in data.iter() {661			<PalletCommon<T>>::ensure_correct_receiver(&data.owner)?;662		}663664		let first_token = <TokensMinted<T>>::get(collection.id);665		let tokens_minted = first_token666			.checked_add(data.len() as u32)667			.ok_or(ArithmeticError::Overflow)?;668		ensure!(669			tokens_minted <= collection.limits.token_limit(),670			<CommonError<T>>::CollectionTokenLimitExceeded671		);672673		let mut balances = BTreeMap::new();674		for data in &data {675			let balance = balances676				.entry(&data.owner)677				.or_insert_with(|| <AccountBalance<T>>::get((collection.id, &data.owner)));678			*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;679680			ensure!(681				*balance <= collection.limits.account_token_ownership_limit(),682				<CommonError<T>>::AccountTokenLimitExceeded,683			);684		}685686		for (i, data) in data.iter().enumerate() {687			let token = TokenId(first_token + i as u32 + 1);688689			<PalletStructure<T>>::check_nesting(690				sender.clone(),691				&data.owner,692				collection.id,693				token,694				nesting_budget,695			)?;696		}697698		// =========699700		with_transaction(|| {701			for (i, data) in data.iter().enumerate() {702				let token = first_token + i as u32 + 1;703704				<TokenData<T>>::insert(705					(collection.id, token),706					ItemData {707						// const_data: data.const_data.clone(),708						owner: data.owner.clone(),709					},710				);711712				<PalletStructure<T>>::nest_if_sent_to_token_unchecked(&data.owner, collection.id, TokenId(token));713714				if let Err(e) = Self::set_token_properties(715					collection,716					sender,717					TokenId(token),718					data.properties.clone().into_inner(),719				) {720					return TransactionOutcome::Rollback(Err(e));721				}722			}723			TransactionOutcome::Commit(Ok(()))724		})?;725726		<TokensMinted<T>>::insert(collection.id, tokens_minted);727		for (account, balance) in balances {728			<AccountBalance<T>>::insert((collection.id, account), balance);729		}730		for (i, data) in data.into_iter().enumerate() {731			let token = first_token + i as u32 + 1;732			<Owned<T>>::insert((collection.id, &data.owner, token), true);733734			<PalletEvm<T>>::deposit_log(735				ERC721Events::Transfer {736					from: H160::default(),737					to: *data.owner.as_eth(),738					token_id: token.into(),739				}740				.to_log(collection_id_to_address(collection.id)),741			);742			<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(743				collection.id,744				TokenId(token),745				data.owner.clone(),746				1,747			));748		}749		Ok(())750	}751752	pub fn set_allowance_unchecked(753		collection: &NonfungibleHandle<T>,754		sender: &T::CrossAccountId,755		token: TokenId,756		spender: Option<&T::CrossAccountId>,757		assume_implicit_eth: bool,758	) {759		if let Some(spender) = spender {760			let old_spender = <Allowance<T>>::get((collection.id, token));761			<Allowance<T>>::insert((collection.id, token), spender);762			// In ERC721 there is only one possible approved user of token, so we set763			// approved user to spender764			<PalletEvm<T>>::deposit_log(765				ERC721Events::Approval {766					owner: *sender.as_eth(),767					approved: *spender.as_eth(),768					token_id: token.into(),769				}770				.to_log(collection_id_to_address(collection.id)),771			);772			// In Unique chain, any token can have any amount of approved users, so we need to773			// set allowance of old owner to 0, and allowance of new owner to 1774			if old_spender.as_ref() != Some(spender) {775				if let Some(old_owner) = old_spender {776					<PalletCommon<T>>::deposit_event(CommonEvent::Approved(777						collection.id,778						token,779						sender.clone(),780						old_owner,781						0,782					));783				}784				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(785					collection.id,786					token,787					sender.clone(),788					spender.clone(),789					1,790				));791			}792		} else {793			let old_spender = <Allowance<T>>::take((collection.id, token));794			if !assume_implicit_eth {795				// In ERC721 there is only one possible approved user of token, so we set796				// approved user to zero address797				<PalletEvm<T>>::deposit_log(798					ERC721Events::Approval {799						owner: *sender.as_eth(),800						approved: H160::default(),801						token_id: token.into(),802					}803					.to_log(collection_id_to_address(collection.id)),804				);805			}806			// In Unique chain, any token can have any amount of approved users, so we need to807			// set allowance of old owner to 0808			if let Some(old_spender) = old_spender {809				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(810					collection.id,811					token,812					sender.clone(),813					old_spender,814					0,815				));816			}817		}818	}819820	pub fn set_allowance(821		collection: &NonfungibleHandle<T>,822		sender: &T::CrossAccountId,823		token: TokenId,824		spender: Option<&T::CrossAccountId>,825	) -> DispatchResult {826		if collection.permissions.access() == AccessMode::AllowList {827			collection.check_allowlist(sender)?;828			if let Some(spender) = spender {829				collection.check_allowlist(spender)?;830			}831		}832833		if let Some(spender) = spender {834			<PalletCommon<T>>::ensure_correct_receiver(spender)?;835		}836		let token_data =837			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;838		if &token_data.owner != sender {839			ensure!(840				collection.ignores_owned_amount(sender),841				<CommonError<T>>::CantApproveMoreThanOwned842			);843		}844845		// =========846847		Self::set_allowance_unchecked(collection, sender, token, spender, false);848		Ok(())849	}850851	fn check_allowed(852		collection: &NonfungibleHandle<T>,853		spender: &T::CrossAccountId,854		from: &T::CrossAccountId,855		token: TokenId,856		nesting_budget: &dyn Budget,857	) -> DispatchResult {858		if spender.conv_eq(from) {859			return Ok(());860		}861		if collection.permissions.access() == AccessMode::AllowList {862			// `from`, `to` checked in [`transfer`]863			collection.check_allowlist(spender)?;864		}865		if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {866			// TODO: should collection owner be allowed to perform this transfer?867			ensure!(868				<PalletStructure<T>>::check_indirectly_owned(869					spender.clone(),870					source.0,871					source.1,872					None,873					nesting_budget874				)?,875				<CommonError<T>>::ApprovedValueTooLow,876			);877			return Ok(());878		}879		if <Allowance<T>>::get((collection.id, token)).as_ref() == Some(spender) {880			return Ok(());881		}882		ensure!(883			collection.ignores_allowance(spender),884			<CommonError<T>>::ApprovedValueTooLow885		);886		Ok(())887	}888889	pub fn transfer_from(890		collection: &NonfungibleHandle<T>,891		spender: &T::CrossAccountId,892		from: &T::CrossAccountId,893		to: &T::CrossAccountId,894		token: TokenId,895		nesting_budget: &dyn Budget,896	) -> DispatchResult {897		Self::check_allowed(collection, spender, from, token, nesting_budget)?;898899		// =========900901		// Allowance is reset in [`transfer`]902		Self::transfer(collection, from, to, token, nesting_budget)903	}904905	pub fn burn_from(906		collection: &NonfungibleHandle<T>,907		spender: &T::CrossAccountId,908		from: &T::CrossAccountId,909		token: TokenId,910		nesting_budget: &dyn Budget,911	) -> DispatchResult {912		Self::check_allowed(collection, spender, from, token, nesting_budget)?;913914		// =========915916		Self::burn(collection, from, token)917	}918919	pub fn check_nesting(920		handle: &NonfungibleHandle<T>,921		sender: T::CrossAccountId,922		from: (CollectionId, TokenId),923		under: TokenId,924		nesting_budget: &dyn Budget,925	) -> DispatchResult {926		fn ensure_sender_allowed<T: Config>(927			collection: CollectionId,928			token: TokenId,929			for_nest: (CollectionId, TokenId),930			sender: T::CrossAccountId,931			budget: &dyn Budget,932		) -> DispatchResult {933			ensure!(934				<PalletStructure<T>>::check_indirectly_owned(935					sender,936					collection,937					token,938					Some(for_nest),939					budget940				)?,941				<CommonError<T>>::OnlyOwnerAllowedToNest,942			);943			Ok(())944		}945		match handle.permissions.nesting() {946			NestingRule::Disabled => fail!(<CommonError<T>>::NestingIsDisabled),947			NestingRule::Owner => {948				ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?949			}950			NestingRule::OwnerRestricted(whitelist) => {951				ensure!(952					whitelist.contains(&from.0),953					<CommonError<T>>::SourceCollectionIsNotAllowedToNest954				);955				ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?956			}957		}958		Ok(())959	}960961	fn nest(962		under: (CollectionId, TokenId),963		to_nest: (CollectionId, TokenId),964	) {965		<TokenChildren<T>>::insert(966			(under.0, under.1, (to_nest.0, to_nest.1)),967			true968		);969	}970971	fn unnest(972		under: (CollectionId, TokenId),973		to_unnest: (CollectionId, TokenId),974	) {975		<TokenChildren<T>>::remove(976			(under.0, under.1, to_unnest)977		);978	}979980	fn collection_has_tokens(collection_id: CollectionId) -> bool {981		<TokenData<T>>::iter_prefix((collection_id,)).next().is_some()982	}983984	fn token_has_children(collection_id: CollectionId, token_id: TokenId) -> bool {985		<TokenChildren<T>>::iter_prefix((collection_id, token_id)).next().is_some()986	}987988	/// Delegated to `create_multiple_items`989	pub fn create_item(990		collection: &NonfungibleHandle<T>,991		sender: &T::CrossAccountId,992		data: CreateItemData<T>,993		nesting_budget: &dyn Budget,994	) -> DispatchResult {995		Self::create_multiple_items(collection, sender, vec![data], nesting_budget)996	}997}