git.delta.rocks / unique-network / refs/commits / 9d51561e5bd0

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	}8384	#[pallet::config]85	pub trait Config:86		frame_system::Config + pallet_common::Config + pallet_structure::Config + pallet_evm::Config87	{88		type WeightInfo: WeightInfo;89	}9091	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);9293	#[pallet::pallet]94	#[pallet::storage_version(STORAGE_VERSION)]95	#[pallet::generate_store(pub(super) trait Store)]96	pub struct Pallet<T>(_);9798	#[pallet::storage]99	pub type TokensMinted<T: Config> =100		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;101	#[pallet::storage]102	pub type TokensBurnt<T: Config> =103		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;104105	#[pallet::storage]106	pub type TokenData<T: Config> = StorageNMap<107		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),108		Value = ItemData<T::CrossAccountId>,109		QueryKind = OptionQuery,110	>;111112	#[pallet::storage]113	#[pallet::getter(fn token_properties)]114	pub type TokenProperties<T: Config> = StorageNMap<115		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),116		Value = Properties,117		QueryKind = ValueQuery,118		OnEmpty = up_data_structs::TokenProperties,119	>;120121	/// Used to enumerate tokens owned by account122	#[pallet::storage]123	pub type Owned<T: Config> = StorageNMap<124		Key = (125			Key<Twox64Concat, CollectionId>,126			Key<Blake2_128Concat, T::CrossAccountId>,127			Key<Twox64Concat, TokenId>,128		),129		Value = bool,130		QueryKind = ValueQuery,131	>;132133	/// Used to enumerate token's children134	#[pallet::storage]135	#[pallet::getter(fn token_children)]136	pub type TokenChildren<T: Config> = StorageNMap<137		Key = (138			Key<Twox64Concat, CollectionId>,139			Key<Twox64Concat, TokenId>,140			Key<Twox64Concat, (CollectionId, TokenId)>,141		),142		Value = bool,143		QueryKind = ValueQuery,144	>;145146	#[pallet::storage]147	pub type AccountBalance<T: Config> = StorageNMap<148		Key = (149			Key<Twox64Concat, CollectionId>,150			Key<Blake2_128Concat, T::CrossAccountId>,151		),152		Value = u32,153		QueryKind = ValueQuery,154	>;155156	#[pallet::storage]157	pub type Allowance<T: Config> = StorageNMap<158		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),159		Value = T::CrossAccountId,160		QueryKind = OptionQuery,161	>;162163	#[pallet::hooks]164	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {165		fn on_runtime_upgrade() -> Weight {166			if StorageVersion::get::<Pallet<T>>() < StorageVersion::new(1) {167				let mut had_consts = BTreeSet::new();168				<TokenData<T>>::translate::<ItemDataVersion1<T::CrossAccountId>, _>(|(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: v.const_data.clone().into_inner().try_into().expect("const too long"),174						});175						had_consts.insert(collection);176					}177					if !v.variable_data.is_empty() {178						props.push(Property {179							key: b"_old_variableData".to_vec().try_into().unwrap(),180							value: v.variable_data.clone().into_inner().try_into().expect("variable too long"),181						})182					}183					if !props.is_empty() {184						Self::set_scoped_token_properties(185							collection,186							token,187							PropertyScope::None,188							props.into_iter(),189						).expect("existing token data exceeds property storage");190					}191					Some(<ItemDataVersion2<T::CrossAccountId>>::from(v))192				});193				for collection in had_consts {194					<PalletCommon<T>>::set_property_permission_unchecked(195						collection,196						PropertyKeyPermission {197							key: b"_old_constData".to_vec().try_into().unwrap(),198							permission: PropertyPermission {199								mutable: false,200								collection_admin: true,201								token_owner: false,202							},203						}204					).expect("failed to configure permission");205				}206			}207208			0209		}210	}211}212213pub struct NonfungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);214impl<T: Config> NonfungibleHandle<T> {215	pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {216		Self(inner)217	}218	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {219		self.0220	}221	pub fn common_mut(&mut self) -> &mut pallet_common::CollectionHandle<T> {222		&mut self.0223	}224}225impl<T: Config> WithRecorder<T> for NonfungibleHandle<T> {226	fn recorder(&self) -> &SubstrateRecorder<T> {227		self.0.recorder()228	}229	fn into_recorder(self) -> SubstrateRecorder<T> {230		self.0.into_recorder()231	}232}233impl<T: Config> Deref for NonfungibleHandle<T> {234	type Target = pallet_common::CollectionHandle<T>;235236	fn deref(&self) -> &Self::Target {237		&self.0238	}239}240241impl<T: Config> Pallet<T> {242	pub fn total_supply(collection: &NonfungibleHandle<T>) -> u32 {243		<TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)244	}245	pub fn token_exists(collection: &NonfungibleHandle<T>, token: TokenId) -> bool {246		<TokenData<T>>::contains_key((collection.id, token))247	}248249	pub fn set_scoped_token_property(250		collection_id: CollectionId,251		token_id: TokenId,252		scope: PropertyScope,253		property: Property,254	) -> DispatchResult {255		TokenProperties::<T>::try_mutate((collection_id, token_id), |properties| {256			properties.try_scoped_set(scope, property.key, property.value)257		})258		.map_err(<CommonError<T>>::from)?;259260		Ok(())261	}262263	pub fn set_scoped_token_properties(264		collection_id: CollectionId,265		token_id: TokenId,266		scope: PropertyScope,267		properties: impl Iterator<Item=Property>,268	) -> DispatchResult {269		TokenProperties::<T>::try_mutate((collection_id, token_id), |stored_properties| {270			stored_properties.try_scoped_set_from_iter(scope, properties)271		})272		.map_err(<CommonError<T>>::from)?;273274		Ok(())275	}276277	pub fn current_token_id(collection_id: CollectionId) -> TokenId {278		TokenId(<TokensMinted<T>>::get(collection_id))279	}280}281282// unchecked calls skips any permission checks283impl<T: Config> Pallet<T> {284	pub fn init_collection(285		owner: T::AccountId,286		data: CreateCollectionData<T::AccountId>,287	) -> Result<CollectionId, DispatchError> {288		<PalletCommon<T>>::init_collection(owner, data)289	}290	pub fn destroy_collection(291		collection: NonfungibleHandle<T>,292		sender: &T::CrossAccountId,293	) -> DispatchResult {294		let id = collection.id;295296		// =========297298		PalletCommon::destroy_collection(collection.0, sender)?;299300		<TokenData<T>>::remove_prefix((id,), None);301		<TokenChildren<T>>::remove_prefix((id,), None);302		<Owned<T>>::remove_prefix((id,), None);303		<TokensMinted<T>>::remove(id);304		<TokensBurnt<T>>::remove(id);305		<Allowance<T>>::remove_prefix((id,), None);306		<AccountBalance<T>>::remove_prefix((id,), None);307		Ok(())308	}309310	pub fn burn(311		collection: &NonfungibleHandle<T>,312		sender: &T::CrossAccountId,313		token: TokenId,314	) -> DispatchResult {315		let token_data =316			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;317		ensure!(318			&token_data.owner == sender319				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(sender)),320			<CommonError<T>>::NoPermission321		);322323		if collection.permissions.access() == AccessMode::AllowList {324			collection.check_allowlist(sender)?;325		}326327		if Self::token_has_children(collection.id, token) {328			return Err(<Error<T>>::CantBurnNftWithChildren.into());329		}330331		let burnt = <TokensBurnt<T>>::get(collection.id)332			.checked_add(1)333			.ok_or(ArithmeticError::Overflow)?;334335		let balance = <AccountBalance<T>>::get((collection.id, token_data.owner.clone()))336			.checked_sub(1)337			.ok_or(ArithmeticError::Overflow)?;338339		if balance == 0 {340			<AccountBalance<T>>::remove((collection.id, token_data.owner.clone()));341		} else {342			<AccountBalance<T>>::insert((collection.id, token_data.owner.clone()), balance);343		}344345		if let Some(owner) = T::CrossTokenAddressMapping::address_to_token(&token_data.owner) {346			Self::unnest(owner, (collection.id, token));347		}348349		// =========350351		<Owned<T>>::remove((collection.id, &token_data.owner, token));352		<TokensBurnt<T>>::insert(collection.id, burnt);353		<TokenData<T>>::remove((collection.id, token));354		<TokenProperties<T>>::remove((collection.id, token));355		let old_spender = <Allowance<T>>::take((collection.id, token));356357		if let Some(old_spender) = old_spender {358			<PalletCommon<T>>::deposit_event(CommonEvent::Approved(359				collection.id,360				token,361				sender.clone(),362				old_spender,363				0,364			));365		}366367		<PalletEvm<T>>::deposit_log(368			ERC721Events::Transfer {369				from: *token_data.owner.as_eth(),370				to: H160::default(),371				token_id: token.into(),372			}373			.to_log(collection_id_to_address(collection.id)),374		);375		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(376			collection.id,377			token,378			token_data.owner,379			1,380		));381		Ok(())382	}383384	pub fn set_token_property(385		collection: &NonfungibleHandle<T>,386		sender: &T::CrossAccountId,387		token_id: TokenId,388		property: Property,389	) -> DispatchResult {390		Self::check_token_change_permission(collection, sender, token_id, &property.key)?;391392		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {393			let property = property.clone();394			properties.try_set(property.key, property.value)395		})396		.map_err(<CommonError<T>>::from)?;397398		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertySet(399			collection.id,400			token_id,401			property.key,402		));403404		Ok(())405	}406407	#[transactional]408	pub fn set_token_properties(409		collection: &NonfungibleHandle<T>,410		sender: &T::CrossAccountId,411		token_id: TokenId,412		properties: Vec<Property>,413	) -> DispatchResult {414		for property in properties {415			Self::set_token_property(collection, sender, token_id, property)?;416		}417418		Ok(())419	}420421	pub fn delete_token_property(422		collection: &NonfungibleHandle<T>,423		sender: &T::CrossAccountId,424		token_id: TokenId,425		property_key: PropertyKey,426	) -> DispatchResult {427		Self::check_token_change_permission(collection, sender, token_id, &property_key)?;428429		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {430			properties.remove(&property_key)431		})432		.map_err(<CommonError<T>>::from)?;433434		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertyDeleted(435			collection.id,436			token_id,437			property_key,438		));439440		Ok(())441	}442443	fn check_token_change_permission(444		collection: &NonfungibleHandle<T>,445		sender: &T::CrossAccountId,446		token_id: TokenId,447		property_key: &PropertyKey,448	) -> DispatchResult {449		let permission = <PalletCommon<T>>::property_permissions(collection.id)450			.get(property_key)451			.cloned()452			.unwrap_or_else(PropertyPermission::none);453454		let token_data = <TokenData<T>>::get((collection.id, token_id))455			.ok_or(<CommonError<T>>::TokenNotFound)?;456457		let check_token_owner = || -> DispatchResult {458			ensure!(&token_data.owner == sender, <CommonError<T>>::NoPermission);459			Ok(())460		};461462		let is_property_exists = TokenProperties::<T>::get((collection.id, token_id))463			.get(property_key)464			.is_some();465466		match permission {467			PropertyPermission { mutable: false, .. } if is_property_exists => {468				Err(<CommonError<T>>::NoPermission.into())469			}470471			PropertyPermission {472				collection_admin,473				token_owner,474				..475			} => {476				let mut check_result = Err(<CommonError<T>>::NoPermission.into());477478				if collection_admin {479					check_result = collection.check_is_owner_or_admin(sender);480				}481482				if token_owner {483					check_result.or_else(|_| check_token_owner())484				} else {485					check_result486				}487			}488		}489	}490491	#[transactional]492	pub fn delete_token_properties(493		collection: &NonfungibleHandle<T>,494		sender: &T::CrossAccountId,495		token_id: TokenId,496		property_keys: Vec<PropertyKey>,497	) -> DispatchResult {498		for key in property_keys {499			Self::delete_token_property(collection, sender, token_id, key)?;500		}501502		Ok(())503	}504505	pub fn set_collection_properties(506		collection: &NonfungibleHandle<T>,507		sender: &T::CrossAccountId,508		properties: Vec<Property>,509	) -> DispatchResult {510		<PalletCommon<T>>::set_collection_properties(collection, sender, properties)511	}512513	pub fn delete_collection_properties(514		collection: &CollectionHandle<T>,515		sender: &T::CrossAccountId,516		property_keys: Vec<PropertyKey>,517	) -> DispatchResult {518		<PalletCommon<T>>::delete_collection_properties(collection, sender, property_keys)519	}520521	pub fn set_property_permissions(522		collection: &CollectionHandle<T>,523		sender: &T::CrossAccountId,524		property_permissions: Vec<PropertyKeyPermission>,525	) -> DispatchResult {526		<PalletCommon<T>>::set_property_permissions(collection, sender, property_permissions)527	}528529	pub fn set_property_permission(530		collection: &CollectionHandle<T>,531		sender: &T::CrossAccountId,532		permission: PropertyKeyPermission,533	) -> DispatchResult {534		<PalletCommon<T>>::set_property_permission(collection, sender, permission)535	}536537	pub fn transfer(538		collection: &NonfungibleHandle<T>,539		from: &T::CrossAccountId,540		to: &T::CrossAccountId,541		token: TokenId,542		nesting_budget: &dyn Budget,543	) -> DispatchResult {544		ensure!(545			collection.limits.transfers_enabled(),546			<CommonError<T>>::TransferNotAllowed547		);548549		let token_data =550			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;551		// TODO: require sender to be token, owner, require admins to go through transfer_from552		ensure!(553			&token_data.owner == from554				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(from)),555			<CommonError<T>>::NoPermission556		);557558		if collection.permissions.access() == AccessMode::AllowList {559			collection.check_allowlist(from)?;560			collection.check_allowlist(to)?;561		}562		<PalletCommon<T>>::ensure_correct_receiver(to)?;563564		let balance_from = <AccountBalance<T>>::get((collection.id, from))565			.checked_sub(1)566			.ok_or(<CommonError<T>>::TokenValueTooLow)?;567		let balance_to = if from != to {568			let balance_to = <AccountBalance<T>>::get((collection.id, to))569				.checked_add(1)570				.ok_or(ArithmeticError::Overflow)?;571572			ensure!(573				balance_to < collection.limits.account_token_ownership_limit(),574				<CommonError<T>>::AccountTokenLimitExceeded,575			);576577			Some(balance_to)578		} else {579			None580		};581582		<PalletStructure<T>>::try_nest_if_sent_to_token(583			from.clone(),584			to,585			collection.id,586			token,587			nesting_budget588		)?;589590		// =========591592		<TokenData<T>>::insert(593			(collection.id, token),594			ItemData {595				owner: to.clone(),596				..token_data597			},598		);599600		if let Some(balance_to) = balance_to {601			// from != to602			if balance_from == 0 {603				<AccountBalance<T>>::remove((collection.id, from));604			} else {605				<AccountBalance<T>>::insert((collection.id, from), balance_from);606			}607			<AccountBalance<T>>::insert((collection.id, to), balance_to);608			<Owned<T>>::remove((collection.id, from, token));609			<Owned<T>>::insert((collection.id, to, token), true);610		}611		Self::set_allowance_unchecked(collection, from, token, None, true);612613		<PalletEvm<T>>::deposit_log(614			ERC721Events::Transfer {615				from: *from.as_eth(),616				to: *to.as_eth(),617				token_id: token.into(),618			}619			.to_log(collection_id_to_address(collection.id)),620		);621		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(622			collection.id,623			token,624			from.clone(),625			to.clone(),626			1,627		));628		Ok(())629	}630631	pub fn create_multiple_items(632		collection: &NonfungibleHandle<T>,633		sender: &T::CrossAccountId,634		data: Vec<CreateItemData<T>>,635		nesting_budget: &dyn Budget,636	) -> DispatchResult {637		if !collection.is_owner_or_admin(sender) {638			ensure!(639				collection.permissions.mint_mode(),640				<CommonError<T>>::PublicMintingNotAllowed641			);642			collection.check_allowlist(sender)?;643644			for item in data.iter() {645				collection.check_allowlist(&item.owner)?;646			}647		}648649		for data in data.iter() {650			<PalletCommon<T>>::ensure_correct_receiver(&data.owner)?;651		}652653		let first_token = <TokensMinted<T>>::get(collection.id);654		let tokens_minted = first_token655			.checked_add(data.len() as u32)656			.ok_or(ArithmeticError::Overflow)?;657		ensure!(658			tokens_minted <= collection.limits.token_limit(),659			<CommonError<T>>::CollectionTokenLimitExceeded660		);661662		let mut balances = BTreeMap::new();663		for data in &data {664			let balance = balances665				.entry(&data.owner)666				.or_insert_with(|| <AccountBalance<T>>::get((collection.id, &data.owner)));667			*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;668669			ensure!(670				*balance <= collection.limits.account_token_ownership_limit(),671				<CommonError<T>>::AccountTokenLimitExceeded,672			);673		}674675		for (i, data) in data.iter().enumerate() {676			let token = TokenId(first_token + i as u32 + 1);677678			<PalletStructure<T>>::check_nesting(679				sender.clone(),680				&data.owner,681				collection.id,682				token,683				nesting_budget,684			)?;685		}686687		// =========688689		with_transaction(|| {690			for (i, data) in data.iter().enumerate() {691				let token = first_token + i as u32 + 1;692693				<TokenData<T>>::insert(694					(collection.id, token),695					ItemData {696						// const_data: data.const_data.clone(),697						owner: data.owner.clone(),698					},699				);700701				<PalletStructure<T>>::nest_if_sent_to_token(&data.owner, collection.id, TokenId(token));702703				if let Err(e) = Self::set_token_properties(704					collection,705					sender,706					TokenId(token),707					data.properties.clone().into_inner(),708				) {709					return TransactionOutcome::Rollback(Err(e));710				}711			}712			TransactionOutcome::Commit(Ok(()))713		})?;714715		<TokensMinted<T>>::insert(collection.id, tokens_minted);716		for (account, balance) in balances {717			<AccountBalance<T>>::insert((collection.id, account), balance);718		}719		for (i, data) in data.into_iter().enumerate() {720			let token = first_token + i as u32 + 1;721			<Owned<T>>::insert((collection.id, &data.owner, token), true);722723			<PalletEvm<T>>::deposit_log(724				ERC721Events::Transfer {725					from: H160::default(),726					to: *data.owner.as_eth(),727					token_id: token.into(),728				}729				.to_log(collection_id_to_address(collection.id)),730			);731			<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(732				collection.id,733				TokenId(token),734				data.owner.clone(),735				1,736			));737		}738		Ok(())739	}740741	pub fn set_allowance_unchecked(742		collection: &NonfungibleHandle<T>,743		sender: &T::CrossAccountId,744		token: TokenId,745		spender: Option<&T::CrossAccountId>,746		assume_implicit_eth: bool,747	) {748		if let Some(spender) = spender {749			let old_spender = <Allowance<T>>::get((collection.id, token));750			<Allowance<T>>::insert((collection.id, token), spender);751			// In ERC721 there is only one possible approved user of token, so we set752			// approved user to spender753			<PalletEvm<T>>::deposit_log(754				ERC721Events::Approval {755					owner: *sender.as_eth(),756					approved: *spender.as_eth(),757					token_id: token.into(),758				}759				.to_log(collection_id_to_address(collection.id)),760			);761			// In Unique chain, any token can have any amount of approved users, so we need to762			// set allowance of old owner to 0, and allowance of new owner to 1763			if old_spender.as_ref() != Some(spender) {764				if let Some(old_owner) = old_spender {765					<PalletCommon<T>>::deposit_event(CommonEvent::Approved(766						collection.id,767						token,768						sender.clone(),769						old_owner,770						0,771					));772				}773				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(774					collection.id,775					token,776					sender.clone(),777					spender.clone(),778					1,779				));780			}781		} else {782			let old_spender = <Allowance<T>>::take((collection.id, token));783			if !assume_implicit_eth {784				// In ERC721 there is only one possible approved user of token, so we set785				// approved user to zero address786				<PalletEvm<T>>::deposit_log(787					ERC721Events::Approval {788						owner: *sender.as_eth(),789						approved: H160::default(),790						token_id: token.into(),791					}792					.to_log(collection_id_to_address(collection.id)),793				);794			}795			// In Unique chain, any token can have any amount of approved users, so we need to796			// set allowance of old owner to 0797			if let Some(old_spender) = old_spender {798				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(799					collection.id,800					token,801					sender.clone(),802					old_spender,803					0,804				));805			}806		}807	}808809	pub fn set_allowance(810		collection: &NonfungibleHandle<T>,811		sender: &T::CrossAccountId,812		token: TokenId,813		spender: Option<&T::CrossAccountId>,814	) -> DispatchResult {815		if collection.permissions.access() == AccessMode::AllowList {816			collection.check_allowlist(sender)?;817			if let Some(spender) = spender {818				collection.check_allowlist(spender)?;819			}820		}821822		if let Some(spender) = spender {823			<PalletCommon<T>>::ensure_correct_receiver(spender)?;824		}825		let token_data =826			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;827		if &token_data.owner != sender {828			ensure!(829				collection.ignores_owned_amount(sender),830				<CommonError<T>>::CantApproveMoreThanOwned831			);832		}833834		// =========835836		Self::set_allowance_unchecked(collection, sender, token, spender, false);837		Ok(())838	}839840	fn check_allowed(841		collection: &NonfungibleHandle<T>,842		spender: &T::CrossAccountId,843		from: &T::CrossAccountId,844		token: TokenId,845		nesting_budget: &dyn Budget,846	) -> DispatchResult {847		if spender.conv_eq(from) {848			return Ok(());849		}850		if collection.permissions.access() == AccessMode::AllowList {851			// `from`, `to` checked in [`transfer`]852			collection.check_allowlist(spender)?;853		}854		if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {855			// TODO: should collection owner be allowed to perform this transfer?856			ensure!(857				<PalletStructure<T>>::check_indirectly_owned(858					spender.clone(),859					source.0,860					source.1,861					None,862					nesting_budget863				)?,864				<CommonError<T>>::ApprovedValueTooLow,865			);866			return Ok(());867		}868		if <Allowance<T>>::get((collection.id, token)).as_ref() == Some(spender) {869			return Ok(());870		}871		ensure!(872			collection.ignores_allowance(spender),873			<CommonError<T>>::ApprovedValueTooLow874		);875		Ok(())876	}877878	pub fn transfer_from(879		collection: &NonfungibleHandle<T>,880		spender: &T::CrossAccountId,881		from: &T::CrossAccountId,882		to: &T::CrossAccountId,883		token: TokenId,884		nesting_budget: &dyn Budget,885	) -> DispatchResult {886		Self::check_allowed(collection, spender, from, token, nesting_budget)?;887888		// =========889890		// Allowance is reset in [`transfer`]891		Self::transfer(collection, from, to, token, nesting_budget)892	}893894	pub fn burn_from(895		collection: &NonfungibleHandle<T>,896		spender: &T::CrossAccountId,897		from: &T::CrossAccountId,898		token: TokenId,899		nesting_budget: &dyn Budget,900	) -> DispatchResult {901		Self::check_allowed(collection, spender, from, token, nesting_budget)?;902903		// =========904905		Self::burn(collection, from, token)906	}907908	pub fn check_nesting(909		handle: &NonfungibleHandle<T>,910		sender: T::CrossAccountId,911		from: (CollectionId, TokenId),912		under: TokenId,913		nesting_budget: &dyn Budget,914	) -> DispatchResult {915		fn ensure_sender_allowed<T: Config>(916			collection: CollectionId,917			token: TokenId,918			for_nest: (CollectionId, TokenId),919			sender: T::CrossAccountId,920			budget: &dyn Budget,921		) -> DispatchResult {922			ensure!(923				<PalletStructure<T>>::check_indirectly_owned(924					sender,925					collection,926					token,927					Some(for_nest),928					budget929				)?,930				<CommonError<T>>::OnlyOwnerAllowedToNest,931			);932			Ok(())933		}934		match handle.permissions.nesting() {935			NestingRule::Disabled => fail!(<CommonError<T>>::NestingIsDisabled),936			NestingRule::Owner => {937				ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?938			}939			NestingRule::OwnerRestricted(whitelist) => {940				ensure!(941					whitelist.contains(&from.0),942					<CommonError<T>>::SourceCollectionIsNotAllowedToNest943				);944				ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?945			}946		}947		Ok(())948	}949950	fn nest(951		under: (CollectionId, TokenId),952		to_nest: (CollectionId, TokenId),953	) {954		<TokenChildren<T>>::insert(955			(under.0, under.1, (to_nest.0, to_nest.1)),956			true957		);958	}959960	fn unnest(961		under: (CollectionId, TokenId),962		to_unnest: (CollectionId, TokenId),963	) {964		<TokenChildren<T>>::remove(965			(under.0, under.1, to_unnest)966		);967	}968969	fn token_has_children(collection_id: CollectionId, token_id: TokenId) -> bool {970		<TokenChildren<T>>::iter_prefix((collection_id, token_id)).next().is_some()971	}972973	/// Delegated to `create_multiple_items`974	pub fn create_item(975		collection: &NonfungibleHandle<T>,976		sender: &T::CrossAccountId,977		data: CreateItemData<T>,978		nesting_budget: &dyn Budget,979	) -> DispatchResult {980		Self::create_multiple_items(collection, sender, vec![data], nesting_budget)981	}982}