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	dispatch::CollectionDispatch,31	eth::collection_id_to_address,32};33use pallet_structure::Pallet as PalletStructure;34use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};35use sp_core::H160;36use sp_runtime::{ArithmeticError, DispatchError, DispatchResult, TransactionOutcome};37use sp_std::{vec::Vec, vec, collections::btree_set::BTreeSet};38use core::ops::Deref;39use sp_std::collections::btree_map::BTreeMap;40use codec::{Encode, Decode, MaxEncodedLen};41use scale_info::TypeInfo;4243pub use pallet::*;44#[cfg(feature = "runtime-benchmarks")]45pub mod benchmarking;46pub mod common;47pub mod erc;48pub mod weights;4950pub type CreateItemData<T> = CreateNftExData<<T as pallet_evm::account::Config>::CrossAccountId>;51pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;5253#[struct_versioning::versioned(version = 2, upper)]54#[derive(Encode, Decode, TypeInfo, MaxEncodedLen)]55pub struct ItemData<CrossAccountId> {56	#[version(..2)]57	pub const_data: BoundedVec<u8, CustomDataLimit>,5859	#[version(..2)]60	pub variable_data: BoundedVec<u8, CustomDataLimit>,6162	pub owner: CrossAccountId,63}6465#[frame_support::pallet]66pub mod pallet {67	use super::*;68	use frame_support::{69		Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key, traits::StorageVersion,70	};71	use frame_system::pallet_prelude::*;72	use up_data_structs::{CollectionId, TokenId};73	use super::weights::WeightInfo;7475	#[pallet::error]76	pub enum Error<T> {77		/// Not Nonfungible item data used to mint in Nonfungible collection.78		NotNonfungibleDataUsedToMintFungibleCollectionToken,79		/// Used amount > 1 with NFT80		NonfungibleItemsHaveNoAmount,81		/// Unable to burn NFT with children82		CantBurnNftWithChildren,83		/// Too many children to burn when destroying a collection84		TooManyChildrenToBurn,85	}8687	#[pallet::config]88	pub trait Config:89		frame_system::Config + pallet_common::Config + pallet_structure::Config + pallet_evm::Config90	{91		type WeightInfo: WeightInfo;92	}9394	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);9596	#[pallet::pallet]97	#[pallet::storage_version(STORAGE_VERSION)]98	#[pallet::generate_store(pub(super) trait Store)]99	pub struct Pallet<T>(_);100101	#[pallet::storage]102	pub type TokensMinted<T: Config> =103		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;104	#[pallet::storage]105	pub type TokensBurnt<T: Config> =106		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;107108	#[pallet::storage]109	pub type TokenData<T: Config> = StorageNMap<110		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),111		Value = ItemData<T::CrossAccountId>,112		QueryKind = OptionQuery,113	>;114115	#[pallet::storage]116	#[pallet::getter(fn token_properties)]117	pub type TokenProperties<T: Config> = StorageNMap<118		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),119		Value = Properties,120		QueryKind = ValueQuery,121		OnEmpty = up_data_structs::TokenProperties,122	>;123124	/// Used to enumerate tokens owned by account125	#[pallet::storage]126	pub type Owned<T: Config> = StorageNMap<127		Key = (128			Key<Twox64Concat, CollectionId>,129			Key<Blake2_128Concat, T::CrossAccountId>,130			Key<Twox64Concat, TokenId>,131		),132		Value = bool,133		QueryKind = ValueQuery,134	>;135136	/// Used to enumerate token's children137	#[pallet::storage]138	#[pallet::getter(fn token_children)]139	pub type TokenChildren<T: Config> = StorageNMap<140		Key = (141			Key<Twox64Concat, CollectionId>,142			Key<Twox64Concat, TokenId>,143			Key<Twox64Concat, (CollectionId, TokenId)>,144		),145		Value = bool,146		QueryKind = ValueQuery,147	>;148149	#[pallet::storage]150	pub type AccountBalance<T: Config> = StorageNMap<151		Key = (152			Key<Twox64Concat, CollectionId>,153			Key<Blake2_128Concat, T::CrossAccountId>,154		),155		Value = u32,156		QueryKind = ValueQuery,157	>;158159	#[pallet::storage]160	pub type Allowance<T: Config> = StorageNMap<161		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),162		Value = T::CrossAccountId,163		QueryKind = OptionQuery,164	>;165166	#[pallet::hooks]167	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {168		fn on_runtime_upgrade() -> Weight {169			if StorageVersion::get::<Pallet<T>>() < StorageVersion::new(1) {170				let mut had_consts = BTreeSet::new();171				<TokenData<T>>::translate::<ItemDataVersion1<T::CrossAccountId>, _>(|(collection, token), v| {172					let mut props = vec![];173					if !v.const_data.is_empty() {174						props.push(Property {175							key: b"_old_constData".to_vec().try_into().unwrap(),176							value: v.const_data.clone().into_inner().try_into().expect("const too long"),177						});178						had_consts.insert(collection);179					}180					if !v.variable_data.is_empty() {181						props.push(Property {182							key: b"_old_variableData".to_vec().try_into().unwrap(),183							value: v.variable_data.clone().into_inner().try_into().expect("variable too long"),184						})185					}186					if !props.is_empty() {187						Self::set_scoped_token_properties(188							collection,189							token,190							PropertyScope::None,191							props.into_iter(),192						).expect("existing token data exceeds property storage");193					}194					Some(<ItemDataVersion2<T::CrossAccountId>>::from(v))195				});196				for collection in had_consts {197					<PalletCommon<T>>::set_property_permission_unchecked(198						collection,199						PropertyKeyPermission {200							key: b"_old_constData".to_vec().try_into().unwrap(),201							permission: PropertyPermission {202								mutable: false,203								collection_admin: true,204								token_owner: false,205							},206						}207					).expect("failed to configure permission");208				}209			}210211			0212		}213	}214}215216pub struct NonfungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);217impl<T: Config> NonfungibleHandle<T> {218	pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {219		Self(inner)220	}221	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {222		self.0223	}224	pub fn common_mut(&mut self) -> &mut pallet_common::CollectionHandle<T> {225		&mut self.0226	}227}228impl<T: Config> WithRecorder<T> for NonfungibleHandle<T> {229	fn recorder(&self) -> &SubstrateRecorder<T> {230		self.0.recorder()231	}232	fn into_recorder(self) -> SubstrateRecorder<T> {233		self.0.into_recorder()234	}235}236impl<T: Config> Deref for NonfungibleHandle<T> {237	type Target = pallet_common::CollectionHandle<T>;238239	fn deref(&self) -> &Self::Target {240		&self.0241	}242}243244impl<T: Config> Pallet<T> {245	pub fn total_supply(collection: &NonfungibleHandle<T>) -> u32 {246		<TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)247	}248	pub fn token_exists(collection: &NonfungibleHandle<T>, token: TokenId) -> bool {249		<TokenData<T>>::contains_key((collection.id, token))250	}251252	pub fn set_scoped_token_property(253		collection_id: CollectionId,254		token_id: TokenId,255		scope: PropertyScope,256		property: Property,257	) -> DispatchResult {258		TokenProperties::<T>::try_mutate((collection_id, token_id), |properties| {259			properties.try_scoped_set(scope, property.key, property.value)260		})261		.map_err(<CommonError<T>>::from)?;262263		Ok(())264	}265266	pub fn set_scoped_token_properties(267		collection_id: CollectionId,268		token_id: TokenId,269		scope: PropertyScope,270		properties: impl Iterator<Item=Property>,271	) -> DispatchResult {272		TokenProperties::<T>::try_mutate((collection_id, token_id), |stored_properties| {273			stored_properties.try_scoped_set_from_iter(scope, properties)274		})275		.map_err(<CommonError<T>>::from)?;276277		Ok(())278	}279280	pub fn current_token_id(collection_id: CollectionId) -> TokenId {281		TokenId(<TokensMinted<T>>::get(collection_id))282	}283}284285// unchecked calls skips any permission checks286impl<T: Config> Pallet<T> {287	pub fn init_collection(288		owner: T::AccountId,289		data: CreateCollectionData<T::AccountId>,290	) -> Result<CollectionId, DispatchError> {291		<PalletCommon<T>>::init_collection(owner, data)292	}293	pub fn destroy_collection(294		collection: NonfungibleHandle<T>,295		sender: &T::CrossAccountId,296		nesting_budget: &dyn Budget,297	) -> DispatchResult {298		let id = collection.id;299300		// =========301302		Self::burn_children_in_collection(id, nesting_budget)?;303		PalletCommon::destroy_collection(collection.0, sender)?;304		<TokenData<T>>::remove_prefix((id,), None);305		<TokenChildren<T>>::remove_prefix((id,), None);306		<Owned<T>>::remove_prefix((id,), None);307		<TokensMinted<T>>::remove(id);308		<TokensBurnt<T>>::remove(id);309		<Allowance<T>>::remove_prefix((id,), None);310		<AccountBalance<T>>::remove_prefix((id,), None);311		Ok(())312	}313314	#[transactional]315	fn burn_children_in_collection(collection_id: CollectionId, nesting_budget: &dyn Budget) -> DispatchResult {316		for (parent_id, child) in <TokenChildren<T>>::drain_prefix((collection_id,))317			.map(|((parent_id, child), _)| (parent_id, child)) {318319			let parent_address = T::CrossTokenAddressMapping::token_to_address(collection_id, parent_id);320			Self::burn_tree(parent_address, child.0, child.1, nesting_budget)?;321		}322323		Ok(())324	}325326	fn burn_tree(327		parent: T::CrossAccountId,328		collection_id: CollectionId,329		token_id: TokenId,330		nesting_budget: &dyn Budget331	) -> DispatchResult {332		if !nesting_budget.consume() {333			return Err(<Error<T>>::TooManyChildrenToBurn.into());334		}335336		let handle = <CollectionHandle<T>>::try_get(collection_id)?;337		let handle = T::CollectionDispatch::dispatch(handle);338		let handle = handle.as_dyn();339340		let amount = handle.balance(parent.clone(), token_id);341342		handle.burn_item_unchecked(&parent, token_id, amount)?;343344		for child in <TokenChildren<T>>::drain_prefix((collection_id, token_id)).map(|(child, _)| child) {345			let parent = T::CrossTokenAddressMapping::token_to_address(collection_id, token_id);346			Self::burn_tree(parent, child.0, child.1, nesting_budget)?;347		}348349		Ok(())350	}351352	pub fn burn(353		collection: &NonfungibleHandle<T>,354		sender: &T::CrossAccountId,355		token: TokenId,356	) -> DispatchResult {357		let token_data =358			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;359		ensure!(360			&token_data.owner == sender361				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(sender)),362			<CommonError<T>>::NoPermission363		);364365		if collection.permissions.access() == AccessMode::AllowList {366			collection.check_allowlist(sender)?;367		}368369		if Self::token_has_children(collection.id, token) {370			return Err(<Error<T>>::CantBurnNftWithChildren.into());371		}372373		let old_spender = <Allowance<T>>::get((collection.id, token));374375		// =========376377		Self::burn_item_unchecked(collection, &token_data.owner, token)?;378379		if let Some(old_spender) = old_spender {380			<PalletCommon<T>>::deposit_event(CommonEvent::Approved(381				collection.id,382				token,383				sender.clone(),384				old_spender,385				0,386			));387		}388389		<PalletEvm<T>>::deposit_log(390			ERC721Events::Transfer {391				from: *token_data.owner.as_eth(),392				to: H160::default(),393				token_id: token.into(),394			}395			.to_log(collection_id_to_address(collection.id)),396		);397		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(398			collection.id,399			token,400			token_data.owner,401			1,402		));403		Ok(())404	}405406	pub fn burn_item_unchecked(407		collection: &NonfungibleHandle<T>,408		owner: &T::CrossAccountId,409		token: TokenId,410	) -> DispatchResult {411		let burnt = <TokensBurnt<T>>::get(collection.id)412			.checked_add(1)413			.ok_or(ArithmeticError::Overflow)?;414415		let balance = <AccountBalance<T>>::get((collection.id, owner.clone()))416			.checked_sub(1)417			.ok_or(ArithmeticError::Overflow)?;418419		// =========420421		if let Some(owner) = T::CrossTokenAddressMapping::address_to_token(owner) {422			Self::unnest(owner, (collection.id, token));423		}424425		if balance == 0 {426			<AccountBalance<T>>::remove((collection.id, owner.clone()));427		} else {428			<AccountBalance<T>>::insert((collection.id, owner.clone()), balance);429		}430431		<Owned<T>>::remove((collection.id, owner, token));432		<TokensBurnt<T>>::insert(collection.id, burnt);433		<TokenData<T>>::remove((collection.id, token));434		<TokenProperties<T>>::remove((collection.id, token));435		<Allowance<T>>::remove((collection.id, token));436437		Ok(())438	}439440	pub fn set_token_property(441		collection: &NonfungibleHandle<T>,442		sender: &T::CrossAccountId,443		token_id: TokenId,444		property: Property,445	) -> DispatchResult {446		Self::check_token_change_permission(collection, sender, token_id, &property.key)?;447448		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {449			let property = property.clone();450			properties.try_set(property.key, property.value)451		})452		.map_err(<CommonError<T>>::from)?;453454		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertySet(455			collection.id,456			token_id,457			property.key,458		));459460		Ok(())461	}462463	#[transactional]464	pub fn set_token_properties(465		collection: &NonfungibleHandle<T>,466		sender: &T::CrossAccountId,467		token_id: TokenId,468		properties: Vec<Property>,469	) -> DispatchResult {470		for property in properties {471			Self::set_token_property(collection, sender, token_id, property)?;472		}473474		Ok(())475	}476477	pub fn delete_token_property(478		collection: &NonfungibleHandle<T>,479		sender: &T::CrossAccountId,480		token_id: TokenId,481		property_key: PropertyKey,482	) -> DispatchResult {483		Self::check_token_change_permission(collection, sender, token_id, &property_key)?;484485		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {486			properties.remove(&property_key)487		})488		.map_err(<CommonError<T>>::from)?;489490		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertyDeleted(491			collection.id,492			token_id,493			property_key,494		));495496		Ok(())497	}498499	fn check_token_change_permission(500		collection: &NonfungibleHandle<T>,501		sender: &T::CrossAccountId,502		token_id: TokenId,503		property_key: &PropertyKey,504	) -> DispatchResult {505		let permission = <PalletCommon<T>>::property_permissions(collection.id)506			.get(property_key)507			.cloned()508			.unwrap_or_else(PropertyPermission::none);509510		let token_data = <TokenData<T>>::get((collection.id, token_id))511			.ok_or(<CommonError<T>>::TokenNotFound)?;512513		let check_token_owner = || -> DispatchResult {514			ensure!(&token_data.owner == sender, <CommonError<T>>::NoPermission);515			Ok(())516		};517518		let is_property_exists = TokenProperties::<T>::get((collection.id, token_id))519			.get(property_key)520			.is_some();521522		match permission {523			PropertyPermission { mutable: false, .. } if is_property_exists => {524				Err(<CommonError<T>>::NoPermission.into())525			}526527			PropertyPermission {528				collection_admin,529				token_owner,530				..531			} => {532				let mut check_result = Err(<CommonError<T>>::NoPermission.into());533534				if collection_admin {535					check_result = collection.check_is_owner_or_admin(sender);536				}537538				if token_owner {539					check_result.or_else(|_| check_token_owner())540				} else {541					check_result542				}543			}544		}545	}546547	#[transactional]548	pub fn delete_token_properties(549		collection: &NonfungibleHandle<T>,550		sender: &T::CrossAccountId,551		token_id: TokenId,552		property_keys: Vec<PropertyKey>,553	) -> DispatchResult {554		for key in property_keys {555			Self::delete_token_property(collection, sender, token_id, key)?;556		}557558		Ok(())559	}560561	pub fn set_collection_properties(562		collection: &NonfungibleHandle<T>,563		sender: &T::CrossAccountId,564		properties: Vec<Property>,565	) -> DispatchResult {566		<PalletCommon<T>>::set_collection_properties(collection, sender, properties)567	}568569	pub fn delete_collection_properties(570		collection: &CollectionHandle<T>,571		sender: &T::CrossAccountId,572		property_keys: Vec<PropertyKey>,573	) -> DispatchResult {574		<PalletCommon<T>>::delete_collection_properties(collection, sender, property_keys)575	}576577	pub fn set_property_permissions(578		collection: &CollectionHandle<T>,579		sender: &T::CrossAccountId,580		property_permissions: Vec<PropertyKeyPermission>,581	) -> DispatchResult {582		<PalletCommon<T>>::set_property_permissions(collection, sender, property_permissions)583	}584585	pub fn set_property_permission(586		collection: &CollectionHandle<T>,587		sender: &T::CrossAccountId,588		permission: PropertyKeyPermission,589	) -> DispatchResult {590		<PalletCommon<T>>::set_property_permission(collection, sender, permission)591	}592593	pub fn transfer(594		collection: &NonfungibleHandle<T>,595		from: &T::CrossAccountId,596		to: &T::CrossAccountId,597		token: TokenId,598		nesting_budget: &dyn Budget,599	) -> DispatchResult {600		ensure!(601			collection.limits.transfers_enabled(),602			<CommonError<T>>::TransferNotAllowed603		);604605		let token_data =606			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;607		// TODO: require sender to be token, owner, require admins to go through transfer_from608		ensure!(609			&token_data.owner == from610				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(from)),611			<CommonError<T>>::NoPermission612		);613614		if collection.permissions.access() == AccessMode::AllowList {615			collection.check_allowlist(from)?;616			collection.check_allowlist(to)?;617		}618		<PalletCommon<T>>::ensure_correct_receiver(to)?;619620		let balance_from = <AccountBalance<T>>::get((collection.id, from))621			.checked_sub(1)622			.ok_or(<CommonError<T>>::TokenValueTooLow)?;623		let balance_to = if from != to {624			let balance_to = <AccountBalance<T>>::get((collection.id, to))625				.checked_add(1)626				.ok_or(ArithmeticError::Overflow)?;627628			ensure!(629				balance_to < collection.limits.account_token_ownership_limit(),630				<CommonError<T>>::AccountTokenLimitExceeded,631			);632633			Some(balance_to)634		} else {635			None636		};637638		<PalletStructure<T>>::try_nest_if_sent_to_token(639			from.clone(),640			to,641			collection.id,642			token,643			nesting_budget644		)?;645646		// =========647648		<TokenData<T>>::insert(649			(collection.id, token),650			ItemData {651				owner: to.clone(),652				..token_data653			},654		);655656		if let Some(balance_to) = balance_to {657			// from != to658			if balance_from == 0 {659				<AccountBalance<T>>::remove((collection.id, from));660			} else {661				<AccountBalance<T>>::insert((collection.id, from), balance_from);662			}663			<AccountBalance<T>>::insert((collection.id, to), balance_to);664			<Owned<T>>::remove((collection.id, from, token));665			<Owned<T>>::insert((collection.id, to, token), true);666		}667		Self::set_allowance_unchecked(collection, from, token, None, true);668669		<PalletEvm<T>>::deposit_log(670			ERC721Events::Transfer {671				from: *from.as_eth(),672				to: *to.as_eth(),673				token_id: token.into(),674			}675			.to_log(collection_id_to_address(collection.id)),676		);677		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(678			collection.id,679			token,680			from.clone(),681			to.clone(),682			1,683		));684		Ok(())685	}686687	pub fn create_multiple_items(688		collection: &NonfungibleHandle<T>,689		sender: &T::CrossAccountId,690		data: Vec<CreateItemData<T>>,691		nesting_budget: &dyn Budget,692	) -> DispatchResult {693		if !collection.is_owner_or_admin(sender) {694			ensure!(695				collection.permissions.mint_mode(),696				<CommonError<T>>::PublicMintingNotAllowed697			);698			collection.check_allowlist(sender)?;699700			for item in data.iter() {701				collection.check_allowlist(&item.owner)?;702			}703		}704705		for data in data.iter() {706			<PalletCommon<T>>::ensure_correct_receiver(&data.owner)?;707		}708709		let first_token = <TokensMinted<T>>::get(collection.id);710		let tokens_minted = first_token711			.checked_add(data.len() as u32)712			.ok_or(ArithmeticError::Overflow)?;713		ensure!(714			tokens_minted <= collection.limits.token_limit(),715			<CommonError<T>>::CollectionTokenLimitExceeded716		);717718		let mut balances = BTreeMap::new();719		for data in &data {720			let balance = balances721				.entry(&data.owner)722				.or_insert_with(|| <AccountBalance<T>>::get((collection.id, &data.owner)));723			*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;724725			ensure!(726				*balance <= collection.limits.account_token_ownership_limit(),727				<CommonError<T>>::AccountTokenLimitExceeded,728			);729		}730731		for (i, data) in data.iter().enumerate() {732			let token = TokenId(first_token + i as u32 + 1);733734			<PalletStructure<T>>::check_nesting(735				sender.clone(),736				&data.owner,737				collection.id,738				token,739				nesting_budget,740			)?;741		}742743		// =========744745		with_transaction(|| {746			for (i, data) in data.iter().enumerate() {747				let token = first_token + i as u32 + 1;748749				<TokenData<T>>::insert(750					(collection.id, token),751					ItemData {752						// const_data: data.const_data.clone(),753						owner: data.owner.clone(),754					},755				);756757				<PalletStructure<T>>::nest_if_sent_to_token(&data.owner, collection.id, TokenId(token));758759				if let Err(e) = Self::set_token_properties(760					collection,761					sender,762					TokenId(token),763					data.properties.clone().into_inner(),764				) {765					return TransactionOutcome::Rollback(Err(e));766				}767			}768			TransactionOutcome::Commit(Ok(()))769		})?;770771		<TokensMinted<T>>::insert(collection.id, tokens_minted);772		for (account, balance) in balances {773			<AccountBalance<T>>::insert((collection.id, account), balance);774		}775		for (i, data) in data.into_iter().enumerate() {776			let token = first_token + i as u32 + 1;777			<Owned<T>>::insert((collection.id, &data.owner, token), true);778779			<PalletEvm<T>>::deposit_log(780				ERC721Events::Transfer {781					from: H160::default(),782					to: *data.owner.as_eth(),783					token_id: token.into(),784				}785				.to_log(collection_id_to_address(collection.id)),786			);787			<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(788				collection.id,789				TokenId(token),790				data.owner.clone(),791				1,792			));793		}794		Ok(())795	}796797	pub fn set_allowance_unchecked(798		collection: &NonfungibleHandle<T>,799		sender: &T::CrossAccountId,800		token: TokenId,801		spender: Option<&T::CrossAccountId>,802		assume_implicit_eth: bool,803	) {804		if let Some(spender) = spender {805			let old_spender = <Allowance<T>>::get((collection.id, token));806			<Allowance<T>>::insert((collection.id, token), spender);807			// In ERC721 there is only one possible approved user of token, so we set808			// approved user to spender809			<PalletEvm<T>>::deposit_log(810				ERC721Events::Approval {811					owner: *sender.as_eth(),812					approved: *spender.as_eth(),813					token_id: token.into(),814				}815				.to_log(collection_id_to_address(collection.id)),816			);817			// In Unique chain, any token can have any amount of approved users, so we need to818			// set allowance of old owner to 0, and allowance of new owner to 1819			if old_spender.as_ref() != Some(spender) {820				if let Some(old_owner) = old_spender {821					<PalletCommon<T>>::deposit_event(CommonEvent::Approved(822						collection.id,823						token,824						sender.clone(),825						old_owner,826						0,827					));828				}829				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(830					collection.id,831					token,832					sender.clone(),833					spender.clone(),834					1,835				));836			}837		} else {838			let old_spender = <Allowance<T>>::take((collection.id, token));839			if !assume_implicit_eth {840				// In ERC721 there is only one possible approved user of token, so we set841				// approved user to zero address842				<PalletEvm<T>>::deposit_log(843					ERC721Events::Approval {844						owner: *sender.as_eth(),845						approved: H160::default(),846						token_id: token.into(),847					}848					.to_log(collection_id_to_address(collection.id)),849				);850			}851			// In Unique chain, any token can have any amount of approved users, so we need to852			// set allowance of old owner to 0853			if let Some(old_spender) = old_spender {854				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(855					collection.id,856					token,857					sender.clone(),858					old_spender,859					0,860				));861			}862		}863	}864865	pub fn set_allowance(866		collection: &NonfungibleHandle<T>,867		sender: &T::CrossAccountId,868		token: TokenId,869		spender: Option<&T::CrossAccountId>,870	) -> DispatchResult {871		if collection.permissions.access() == AccessMode::AllowList {872			collection.check_allowlist(sender)?;873			if let Some(spender) = spender {874				collection.check_allowlist(spender)?;875			}876		}877878		if let Some(spender) = spender {879			<PalletCommon<T>>::ensure_correct_receiver(spender)?;880		}881		let token_data =882			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;883		if &token_data.owner != sender {884			ensure!(885				collection.ignores_owned_amount(sender),886				<CommonError<T>>::CantApproveMoreThanOwned887			);888		}889890		// =========891892		Self::set_allowance_unchecked(collection, sender, token, spender, false);893		Ok(())894	}895896	fn check_allowed(897		collection: &NonfungibleHandle<T>,898		spender: &T::CrossAccountId,899		from: &T::CrossAccountId,900		token: TokenId,901		nesting_budget: &dyn Budget,902	) -> DispatchResult {903		if spender.conv_eq(from) {904			return Ok(());905		}906		if collection.permissions.access() == AccessMode::AllowList {907			// `from`, `to` checked in [`transfer`]908			collection.check_allowlist(spender)?;909		}910		if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {911			// TODO: should collection owner be allowed to perform this transfer?912			ensure!(913				<PalletStructure<T>>::check_indirectly_owned(914					spender.clone(),915					source.0,916					source.1,917					None,918					nesting_budget919				)?,920				<CommonError<T>>::ApprovedValueTooLow,921			);922			return Ok(());923		}924		if <Allowance<T>>::get((collection.id, token)).as_ref() == Some(spender) {925			return Ok(());926		}927		ensure!(928			collection.ignores_allowance(spender),929			<CommonError<T>>::ApprovedValueTooLow930		);931		Ok(())932	}933934	pub fn transfer_from(935		collection: &NonfungibleHandle<T>,936		spender: &T::CrossAccountId,937		from: &T::CrossAccountId,938		to: &T::CrossAccountId,939		token: TokenId,940		nesting_budget: &dyn Budget,941	) -> DispatchResult {942		Self::check_allowed(collection, spender, from, token, nesting_budget)?;943944		// =========945946		// Allowance is reset in [`transfer`]947		Self::transfer(collection, from, to, token, nesting_budget)948	}949950	pub fn burn_from(951		collection: &NonfungibleHandle<T>,952		spender: &T::CrossAccountId,953		from: &T::CrossAccountId,954		token: TokenId,955		nesting_budget: &dyn Budget,956	) -> DispatchResult {957		Self::check_allowed(collection, spender, from, token, nesting_budget)?;958959		// =========960961		Self::burn(collection, from, token)962	}963964	pub fn check_nesting(965		handle: &NonfungibleHandle<T>,966		sender: T::CrossAccountId,967		from: (CollectionId, TokenId),968		under: TokenId,969		nesting_budget: &dyn Budget,970	) -> DispatchResult {971		fn ensure_sender_allowed<T: Config>(972			collection: CollectionId,973			token: TokenId,974			for_nest: (CollectionId, TokenId),975			sender: T::CrossAccountId,976			budget: &dyn Budget,977		) -> DispatchResult {978			ensure!(979				<PalletStructure<T>>::check_indirectly_owned(980					sender,981					collection,982					token,983					Some(for_nest),984					budget985				)?,986				<CommonError<T>>::OnlyOwnerAllowedToNest,987			);988			Ok(())989		}990		match handle.permissions.nesting() {991			NestingRule::Disabled => fail!(<CommonError<T>>::NestingIsDisabled),992			NestingRule::Owner => {993				ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?994			}995			NestingRule::OwnerRestricted(whitelist) => {996				ensure!(997					whitelist.contains(&from.0),998					<CommonError<T>>::SourceCollectionIsNotAllowedToNest999				);1000				ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?1001			}1002		}1003		Ok(())1004	}10051006	fn nest(1007		under: (CollectionId, TokenId),1008		to_nest: (CollectionId, TokenId),1009	) {1010		<TokenChildren<T>>::insert(1011			(under.0, under.1, (to_nest.0, to_nest.1)),1012			true1013		);1014	}10151016	fn unnest(1017		under: (CollectionId, TokenId),1018		to_unnest: (CollectionId, TokenId),1019	) {1020		<TokenChildren<T>>::remove(1021			(under.0, under.1, to_unnest)1022		);1023	}10241025	fn token_has_children(collection_id: CollectionId, token_id: TokenId) -> bool {1026		<TokenChildren<T>>::iter_prefix((collection_id, token_id)).next().is_some()1027	}10281029	/// Delegated to `create_multiple_items`1030	pub fn create_item(1031		collection: &NonfungibleHandle<T>,1032		sender: &T::CrossAccountId,1033		data: CreateItemData<T>,1034		nesting_budget: &dyn Budget,1035	) -> DispatchResult {1036		Self::create_multiple_items(collection, sender, vec![data], nesting_budget)1037	}1038}