git.delta.rocks / unique-network / refs/commits / 1062e172486e

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	dispatch::CollectionDispatch, 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	}8182	#[pallet::config]83	pub trait Config:84		frame_system::Config + pallet_common::Config + pallet_structure::Config + pallet_evm::Config85	{86		type WeightInfo: WeightInfo;87	}8889	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);9091	#[pallet::pallet]92	#[pallet::storage_version(STORAGE_VERSION)]93	#[pallet::generate_store(pub(super) trait Store)]94	pub struct Pallet<T>(_);9596	#[pallet::storage]97	pub type TokensMinted<T: Config> =98		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;99	#[pallet::storage]100	pub type TokensBurnt<T: Config> =101		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;102103	#[pallet::storage]104	pub type TokenData<T: Config> = StorageNMap<105		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),106		Value = ItemData<T::CrossAccountId>,107		QueryKind = OptionQuery,108	>;109110	#[pallet::storage]111	#[pallet::getter(fn token_properties)]112	pub type TokenProperties<T: Config> = StorageNMap<113		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),114		Value = Properties,115		QueryKind = ValueQuery,116		OnEmpty = up_data_structs::TokenProperties,117	>;118119	/// Used to enumerate tokens owned by account120	#[pallet::storage]121	pub type Owned<T: Config> = StorageNMap<122		Key = (123			Key<Twox64Concat, CollectionId>,124			Key<Blake2_128Concat, T::CrossAccountId>,125			Key<Twox64Concat, TokenId>,126		),127		Value = bool,128		QueryKind = ValueQuery,129	>;130131	#[pallet::storage]132	pub type AccountBalance<T: Config> = StorageNMap<133		Key = (134			Key<Twox64Concat, CollectionId>,135			Key<Blake2_128Concat, T::CrossAccountId>,136		),137		Value = u32,138		QueryKind = ValueQuery,139	>;140141	#[pallet::storage]142	pub type Allowance<T: Config> = StorageNMap<143		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),144		Value = T::CrossAccountId,145		QueryKind = OptionQuery,146	>;147148	#[pallet::hooks]149	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {150		fn on_runtime_upgrade() -> Weight {151			if StorageVersion::get::<Pallet<T>>() < StorageVersion::new(1) {152				let mut had_consts = BTreeSet::new();153				<TokenData<T>>::translate::<ItemDataVersion1<T::CrossAccountId>, _>(|(collection, token), v| {154					let mut props = vec![];155					if !v.const_data.is_empty() {156						props.push(Property {157							key: b"_old_constData".to_vec().try_into().unwrap(),158							value: v.const_data.clone().into_inner().try_into().expect("const too long"),159						});160						had_consts.insert(collection);161					}162					if !v.variable_data.is_empty() {163						props.push(Property {164							key: b"_old_variableData".to_vec().try_into().unwrap(),165							value: v.variable_data.clone().into_inner().try_into().expect("variable too long"),166						})167					}168					if !props.is_empty() {169						Self::set_scoped_token_properties(170							collection,171							token,172							PropertyScope::None,173							props.into_iter(),174						).expect("existing token data exceeds property storage");175					}176					Some(<ItemDataVersion2<T::CrossAccountId>>::from(v))177				});178				for collection in had_consts {179					<PalletCommon<T>>::set_property_permission_unchecked(180						collection,181						PropertyKeyPermission {182							key: b"_old_constData".to_vec().try_into().unwrap(),183							permission: PropertyPermission {184								mutable: false,185								collection_admin: true,186								token_owner: false,187							},188						}189					).expect("failed to configure permission");190				}191			}192193			0194		}195	}196}197198pub struct NonfungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);199impl<T: Config> NonfungibleHandle<T> {200	pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {201		Self(inner)202	}203	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {204		self.0205	}206	pub fn common_mut(&mut self) -> &mut pallet_common::CollectionHandle<T> {207		&mut self.0208	}209}210impl<T: Config> WithRecorder<T> for NonfungibleHandle<T> {211	fn recorder(&self) -> &SubstrateRecorder<T> {212		self.0.recorder()213	}214	fn into_recorder(self) -> SubstrateRecorder<T> {215		self.0.into_recorder()216	}217}218impl<T: Config> Deref for NonfungibleHandle<T> {219	type Target = pallet_common::CollectionHandle<T>;220221	fn deref(&self) -> &Self::Target {222		&self.0223	}224}225226impl<T: Config> Pallet<T> {227	pub fn total_supply(collection: &NonfungibleHandle<T>) -> u32 {228		<TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)229	}230	pub fn token_exists(collection: &NonfungibleHandle<T>, token: TokenId) -> bool {231		<TokenData<T>>::contains_key((collection.id, token))232	}233234	pub fn set_scoped_token_property(235		collection_id: CollectionId,236		token_id: TokenId,237		scope: PropertyScope,238		property: Property,239	) -> DispatchResult {240		TokenProperties::<T>::try_mutate((collection_id, token_id), |properties| {241			properties.try_scoped_set(scope, property.key, property.value)242		})243		.map_err(<CommonError<T>>::from)?;244245		Ok(())246	}247248	pub fn set_scoped_token_properties(249		collection_id: CollectionId,250		token_id: TokenId,251		scope: PropertyScope,252		properties: impl Iterator<Item=Property>,253	) -> DispatchResult {254		TokenProperties::<T>::try_mutate((collection_id, token_id), |stored_properties| {255			stored_properties.try_scoped_set_from_iter(scope, properties)256		})257		.map_err(<CommonError<T>>::from)?;258259		Ok(())260	}261262	pub fn current_token_id(collection_id: CollectionId) -> TokenId {263		TokenId(<TokensMinted<T>>::get(collection_id))264	}265}266267// unchecked calls skips any permission checks268impl<T: Config> Pallet<T> {269	pub fn init_collection(270		owner: T::AccountId,271		data: CreateCollectionData<T::AccountId>,272	) -> Result<CollectionId, DispatchError> {273		<PalletCommon<T>>::init_collection(owner, data)274	}275	pub fn destroy_collection(276		collection: NonfungibleHandle<T>,277		sender: &T::CrossAccountId,278	) -> DispatchResult {279		let id = collection.id;280281		// =========282283		PalletCommon::destroy_collection(collection.0, sender)?;284285		<TokenData<T>>::remove_prefix((id,), None);286		<Owned<T>>::remove_prefix((id,), None);287		<TokensMinted<T>>::remove(id);288		<TokensBurnt<T>>::remove(id);289		<Allowance<T>>::remove_prefix((id,), None);290		<AccountBalance<T>>::remove_prefix((id,), None);291		Ok(())292	}293294	pub fn burn(295		collection: &NonfungibleHandle<T>,296		sender: &T::CrossAccountId,297		token: TokenId,298	) -> DispatchResult {299		let token_data =300			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;301		ensure!(302			&token_data.owner == sender303				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(sender)),304			<CommonError<T>>::NoPermission305		);306307		if collection.permissions.access() == AccessMode::AllowList {308			collection.check_allowlist(sender)?;309		}310311		let burnt = <TokensBurnt<T>>::get(collection.id)312			.checked_add(1)313			.ok_or(ArithmeticError::Overflow)?;314315		let balance = <AccountBalance<T>>::get((collection.id, token_data.owner.clone()))316			.checked_sub(1)317			.ok_or(ArithmeticError::Overflow)?;318319		if balance == 0 {320			<AccountBalance<T>>::remove((collection.id, token_data.owner.clone()));321		} else {322			<AccountBalance<T>>::insert((collection.id, token_data.owner.clone()), balance);323		}324		// =========325326		<Owned<T>>::remove((collection.id, &token_data.owner, token));327		<TokensBurnt<T>>::insert(collection.id, burnt);328		<TokenData<T>>::remove((collection.id, token));329		<TokenProperties<T>>::remove((collection.id, token));330		let old_spender = <Allowance<T>>::take((collection.id, token));331332		if let Some(old_spender) = old_spender {333			<PalletCommon<T>>::deposit_event(CommonEvent::Approved(334				collection.id,335				token,336				sender.clone(),337				old_spender,338				0,339			));340		}341342		<PalletEvm<T>>::deposit_log(343			ERC721Events::Transfer {344				from: *token_data.owner.as_eth(),345				to: H160::default(),346				token_id: token.into(),347			}348			.to_log(collection_id_to_address(collection.id)),349		);350		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(351			collection.id,352			token,353			token_data.owner,354			1,355		));356		Ok(())357	}358359	pub fn set_token_property(360		collection: &NonfungibleHandle<T>,361		sender: &T::CrossAccountId,362		token_id: TokenId,363		property: Property,364	) -> DispatchResult {365		Self::check_token_change_permission(collection, sender, token_id, &property.key)?;366367		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {368			let property = property.clone();369			properties.try_set(property.key, property.value)370		})371		.map_err(<CommonError<T>>::from)?;372373		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertySet(374			collection.id,375			token_id,376			property.key,377		));378379		Ok(())380	}381382	#[transactional]383	pub fn set_token_properties(384		collection: &NonfungibleHandle<T>,385		sender: &T::CrossAccountId,386		token_id: TokenId,387		properties: Vec<Property>,388	) -> DispatchResult {389		for property in properties {390			Self::set_token_property(collection, sender, token_id, property)?;391		}392393		Ok(())394	}395396	pub fn delete_token_property(397		collection: &NonfungibleHandle<T>,398		sender: &T::CrossAccountId,399		token_id: TokenId,400		property_key: PropertyKey,401	) -> DispatchResult {402		Self::check_token_change_permission(collection, sender, token_id, &property_key)?;403404		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {405			properties.remove(&property_key)406		})407		.map_err(<CommonError<T>>::from)?;408409		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertyDeleted(410			collection.id,411			token_id,412			property_key,413		));414415		Ok(())416	}417418	fn check_token_change_permission(419		collection: &NonfungibleHandle<T>,420		sender: &T::CrossAccountId,421		token_id: TokenId,422		property_key: &PropertyKey,423	) -> DispatchResult {424		let permission = <PalletCommon<T>>::property_permissions(collection.id)425			.get(property_key)426			.cloned()427			.unwrap_or_else(PropertyPermission::none);428429		let token_data = <TokenData<T>>::get((collection.id, token_id))430			.ok_or(<CommonError<T>>::TokenNotFound)?;431432		let check_token_owner = || -> DispatchResult {433			ensure!(&token_data.owner == sender, <CommonError<T>>::NoPermission);434			Ok(())435		};436437		let is_property_exists = TokenProperties::<T>::get((collection.id, token_id))438			.get(property_key)439			.is_some();440441		match permission {442			PropertyPermission { mutable: false, .. } if is_property_exists => {443				Err(<CommonError<T>>::NoPermission.into())444			}445446			PropertyPermission {447				collection_admin,448				token_owner,449				..450			} => {451				let mut check_result = Err(<CommonError<T>>::NoPermission.into());452453				if collection_admin {454					check_result = collection.check_is_owner_or_admin(sender);455				}456457				if token_owner {458					check_result.or_else(|_| check_token_owner())459				} else {460					check_result461				}462			}463		}464	}465466	#[transactional]467	pub fn delete_token_properties(468		collection: &NonfungibleHandle<T>,469		sender: &T::CrossAccountId,470		token_id: TokenId,471		property_keys: Vec<PropertyKey>,472	) -> DispatchResult {473		for key in property_keys {474			Self::delete_token_property(collection, sender, token_id, key)?;475		}476477		Ok(())478	}479480	pub fn set_collection_properties(481		collection: &NonfungibleHandle<T>,482		sender: &T::CrossAccountId,483		properties: Vec<Property>,484	) -> DispatchResult {485		<PalletCommon<T>>::set_collection_properties(collection, sender, properties)486	}487488	pub fn delete_collection_properties(489		collection: &CollectionHandle<T>,490		sender: &T::CrossAccountId,491		property_keys: Vec<PropertyKey>,492	) -> DispatchResult {493		<PalletCommon<T>>::delete_collection_properties(collection, sender, property_keys)494	}495496	pub fn set_property_permissions(497		collection: &CollectionHandle<T>,498		sender: &T::CrossAccountId,499		property_permissions: Vec<PropertyKeyPermission>,500	) -> DispatchResult {501		<PalletCommon<T>>::set_property_permissions(collection, sender, property_permissions)502	}503504	pub fn set_property_permission(505		collection: &CollectionHandle<T>,506		sender: &T::CrossAccountId,507		permission: PropertyKeyPermission,508	) -> DispatchResult {509		<PalletCommon<T>>::set_property_permission(collection, sender, permission)510	}511512	pub fn transfer(513		collection: &NonfungibleHandle<T>,514		from: &T::CrossAccountId,515		to: &T::CrossAccountId,516		token: TokenId,517		nesting_budget: &dyn Budget,518	) -> DispatchResult {519		ensure!(520			collection.limits.transfers_enabled(),521			<CommonError<T>>::TransferNotAllowed522		);523524		let token_data =525			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;526		// TODO: require sender to be token, owner, require admins to go through transfer_from527		ensure!(528			&token_data.owner == from529				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(from)),530			<CommonError<T>>::NoPermission531		);532533		if collection.permissions.access() == AccessMode::AllowList {534			collection.check_allowlist(from)?;535			collection.check_allowlist(to)?;536		}537		<PalletCommon<T>>::ensure_correct_receiver(to)?;538539		let balance_from = <AccountBalance<T>>::get((collection.id, from))540			.checked_sub(1)541			.ok_or(<CommonError<T>>::TokenValueTooLow)?;542		let balance_to = if from != to {543			let balance_to = <AccountBalance<T>>::get((collection.id, to))544				.checked_add(1)545				.ok_or(ArithmeticError::Overflow)?;546547			ensure!(548				balance_to < collection.limits.account_token_ownership_limit(),549				<CommonError<T>>::AccountTokenLimitExceeded,550			);551552			Some(balance_to)553		} else {554			None555		};556557		if let Some(target) = T::CrossTokenAddressMapping::address_to_token(to) {558			let handle = <CollectionHandle<T>>::try_get(target.0)?;559			let dispatch = T::CollectionDispatch::dispatch(handle);560			let dispatch = dispatch.as_dyn();561562			dispatch.check_nesting(563				from.clone(),564				(collection.id, token),565				target.1,566				nesting_budget,567			)?;568		}569570		// =========571572		<TokenData<T>>::insert(573			(collection.id, token),574			ItemData {575				owner: to.clone(),576				..token_data577			},578		);579580		if let Some(balance_to) = balance_to {581			// from != to582			if balance_from == 0 {583				<AccountBalance<T>>::remove((collection.id, from));584			} else {585				<AccountBalance<T>>::insert((collection.id, from), balance_from);586			}587			<AccountBalance<T>>::insert((collection.id, to), balance_to);588			<Owned<T>>::remove((collection.id, from, token));589			<Owned<T>>::insert((collection.id, to, token), true);590		}591		Self::set_allowance_unchecked(collection, from, token, None, true);592593		<PalletEvm<T>>::deposit_log(594			ERC721Events::Transfer {595				from: *from.as_eth(),596				to: *to.as_eth(),597				token_id: token.into(),598			}599			.to_log(collection_id_to_address(collection.id)),600		);601		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(602			collection.id,603			token,604			from.clone(),605			to.clone(),606			1,607		));608		Ok(())609	}610611	pub fn create_multiple_items(612		collection: &NonfungibleHandle<T>,613		sender: &T::CrossAccountId,614		data: Vec<CreateItemData<T>>,615		nesting_budget: &dyn Budget,616	) -> DispatchResult {617		if !collection.is_owner_or_admin(sender) {618			ensure!(619				collection.permissions.mint_mode(),620				<CommonError<T>>::PublicMintingNotAllowed621			);622			collection.check_allowlist(sender)?;623624			for item in data.iter() {625				collection.check_allowlist(&item.owner)?;626			}627		}628629		for data in data.iter() {630			<PalletCommon<T>>::ensure_correct_receiver(&data.owner)?;631		}632633		let first_token = <TokensMinted<T>>::get(collection.id);634		let tokens_minted = first_token635			.checked_add(data.len() as u32)636			.ok_or(ArithmeticError::Overflow)?;637		ensure!(638			tokens_minted <= collection.limits.token_limit(),639			<CommonError<T>>::CollectionTokenLimitExceeded640		);641642		let mut balances = BTreeMap::new();643		for data in &data {644			let balance = balances645				.entry(&data.owner)646				.or_insert_with(|| <AccountBalance<T>>::get((collection.id, &data.owner)));647			*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;648649			ensure!(650				*balance <= collection.limits.account_token_ownership_limit(),651				<CommonError<T>>::AccountTokenLimitExceeded,652			);653		}654655		for (i, data) in data.iter().enumerate() {656			let token = TokenId(first_token + i as u32 + 1);657			if let Some(target) = T::CrossTokenAddressMapping::address_to_token(&data.owner) {658				let handle = <CollectionHandle<T>>::try_get(target.0)?;659				let dispatch = T::CollectionDispatch::dispatch(handle);660				let dispatch = dispatch.as_dyn();661				dispatch.check_nesting(662					sender.clone(),663					(collection.id, token),664					target.1,665					nesting_budget,666				)?;667			}668		}669670		// =========671672		with_transaction(|| {673			for (i, data) in data.iter().enumerate() {674				let token = first_token + i as u32 + 1;675676				<TokenData<T>>::insert(677					(collection.id, token),678					ItemData {679						// const_data: data.const_data.clone(),680						owner: data.owner.clone(),681					},682				);683684				if let Err(e) = Self::set_token_properties(685					collection,686					sender,687					TokenId(token),688					data.properties.clone().into_inner(),689				) {690					return TransactionOutcome::Rollback(Err(e));691				}692			}693			TransactionOutcome::Commit(Ok(()))694		})?;695696		<TokensMinted<T>>::insert(collection.id, tokens_minted);697		for (account, balance) in balances {698			<AccountBalance<T>>::insert((collection.id, account), balance);699		}700		for (i, data) in data.into_iter().enumerate() {701			let token = first_token + i as u32 + 1;702			<Owned<T>>::insert((collection.id, &data.owner, token), true);703704			<PalletEvm<T>>::deposit_log(705				ERC721Events::Transfer {706					from: H160::default(),707					to: *data.owner.as_eth(),708					token_id: token.into(),709				}710				.to_log(collection_id_to_address(collection.id)),711			);712			<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(713				collection.id,714				TokenId(token),715				data.owner.clone(),716				1,717			));718		}719		Ok(())720	}721722	pub fn set_allowance_unchecked(723		collection: &NonfungibleHandle<T>,724		sender: &T::CrossAccountId,725		token: TokenId,726		spender: Option<&T::CrossAccountId>,727		assume_implicit_eth: bool,728	) {729		if let Some(spender) = spender {730			let old_spender = <Allowance<T>>::get((collection.id, token));731			<Allowance<T>>::insert((collection.id, token), spender);732			// In ERC721 there is only one possible approved user of token, so we set733			// approved user to spender734			<PalletEvm<T>>::deposit_log(735				ERC721Events::Approval {736					owner: *sender.as_eth(),737					approved: *spender.as_eth(),738					token_id: token.into(),739				}740				.to_log(collection_id_to_address(collection.id)),741			);742			// In Unique chain, any token can have any amount of approved users, so we need to743			// set allowance of old owner to 0, and allowance of new owner to 1744			if old_spender.as_ref() != Some(spender) {745				if let Some(old_owner) = old_spender {746					<PalletCommon<T>>::deposit_event(CommonEvent::Approved(747						collection.id,748						token,749						sender.clone(),750						old_owner,751						0,752					));753				}754				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(755					collection.id,756					token,757					sender.clone(),758					spender.clone(),759					1,760				));761			}762		} else {763			let old_spender = <Allowance<T>>::take((collection.id, token));764			if !assume_implicit_eth {765				// In ERC721 there is only one possible approved user of token, so we set766				// approved user to zero address767				<PalletEvm<T>>::deposit_log(768					ERC721Events::Approval {769						owner: *sender.as_eth(),770						approved: H160::default(),771						token_id: token.into(),772					}773					.to_log(collection_id_to_address(collection.id)),774				);775			}776			// In Unique chain, any token can have any amount of approved users, so we need to777			// set allowance of old owner to 0778			if let Some(old_spender) = old_spender {779				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(780					collection.id,781					token,782					sender.clone(),783					old_spender,784					0,785				));786			}787		}788	}789790	pub fn set_allowance(791		collection: &NonfungibleHandle<T>,792		sender: &T::CrossAccountId,793		token: TokenId,794		spender: Option<&T::CrossAccountId>,795	) -> DispatchResult {796		if collection.permissions.access() == AccessMode::AllowList {797			collection.check_allowlist(sender)?;798			if let Some(spender) = spender {799				collection.check_allowlist(spender)?;800			}801		}802803		if let Some(spender) = spender {804			<PalletCommon<T>>::ensure_correct_receiver(spender)?;805		}806		let token_data =807			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;808		if &token_data.owner != sender {809			ensure!(810				collection.ignores_owned_amount(sender),811				<CommonError<T>>::CantApproveMoreThanOwned812			);813		}814815		// =========816817		Self::set_allowance_unchecked(collection, sender, token, spender, false);818		Ok(())819	}820821	fn check_allowed(822		collection: &NonfungibleHandle<T>,823		spender: &T::CrossAccountId,824		from: &T::CrossAccountId,825		token: TokenId,826		nesting_budget: &dyn Budget,827	) -> DispatchResult {828		if spender.conv_eq(from) {829			return Ok(());830		}831		if collection.permissions.access() == AccessMode::AllowList {832			// `from`, `to` checked in [`transfer`]833			collection.check_allowlist(spender)?;834		}835		if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {836			// TODO: should collection owner be allowed to perform this transfer?837			ensure!(838				<PalletStructure<T>>::check_indirectly_owned(839					spender.clone(),840					source.0,841					source.1,842					None,843					nesting_budget844				)?,845				<CommonError<T>>::ApprovedValueTooLow,846			);847			return Ok(());848		}849		if <Allowance<T>>::get((collection.id, token)).as_ref() == Some(spender) {850			return Ok(());851		}852		ensure!(853			collection.ignores_allowance(spender),854			<CommonError<T>>::ApprovedValueTooLow855		);856		Ok(())857	}858859	pub fn transfer_from(860		collection: &NonfungibleHandle<T>,861		spender: &T::CrossAccountId,862		from: &T::CrossAccountId,863		to: &T::CrossAccountId,864		token: TokenId,865		nesting_budget: &dyn Budget,866	) -> DispatchResult {867		Self::check_allowed(collection, spender, from, token, nesting_budget)?;868869		// =========870871		// Allowance is reset in [`transfer`]872		Self::transfer(collection, from, to, token, nesting_budget)873	}874875	pub fn burn_from(876		collection: &NonfungibleHandle<T>,877		spender: &T::CrossAccountId,878		from: &T::CrossAccountId,879		token: TokenId,880		nesting_budget: &dyn Budget,881	) -> DispatchResult {882		Self::check_allowed(collection, spender, from, token, nesting_budget)?;883884		// =========885886		Self::burn(collection, from, token)887	}888889	pub fn check_nesting(890		handle: &NonfungibleHandle<T>,891		sender: T::CrossAccountId,892		from: (CollectionId, TokenId),893		under: TokenId,894		nesting_budget: &dyn Budget,895	) -> DispatchResult {896		fn ensure_sender_allowed<T: Config>(897			collection: CollectionId,898			token: TokenId,899			for_nest: (CollectionId, TokenId),900			sender: T::CrossAccountId,901			budget: &dyn Budget,902		) -> DispatchResult {903			ensure!(904				<PalletStructure<T>>::check_indirectly_owned(905					sender,906					collection,907					token,908					Some(for_nest),909					budget910				)?,911				<CommonError<T>>::OnlyOwnerAllowedToNest,912			);913			Ok(())914		}915		match handle.permissions.nesting() {916			NestingRule::Disabled => fail!(<CommonError<T>>::NestingIsDisabled),917			NestingRule::Owner => {918				ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?919			}920			NestingRule::OwnerRestricted(whitelist) => {921				ensure!(922					whitelist.contains(&from.0),923					<CommonError<T>>::SourceCollectionIsNotAllowedToNest924				);925				ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?926			}927		}928		Ok(())929	}930931	/// Delegated to `create_multiple_items`932	pub fn create_item(933		collection: &NonfungibleHandle<T>,934		sender: &T::CrossAccountId,935		data: CreateItemData<T>,936		nesting_budget: &dyn Budget,937	) -> DispatchResult {938		Self::create_multiple_items(collection, sender, vec![data], nesting_budget)939	}940}