git.delta.rocks / unique-network / refs/commits / 2050a76c8808

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::{22	BoundedVec, ensure, fail, transactional,23	storage::with_transaction,24	pallet_prelude::DispatchResultWithPostInfo,25	pallet_prelude::Weight,26	weights::{PostDispatchInfo, Pays},27};28use up_data_structs::{29	AccessMode, CollectionId, CustomDataLimit, TokenId, CreateCollectionData, CreateNftExData,30	mapping::TokenAddressMapping, NestingRule, budget::Budget, Property, PropertyPermission,31	PropertyKey, PropertyKeyPermission, Properties, PropertyScope, TrySetProperty, TokenChild,32};33use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};34use pallet_common::{35	Error as CommonError, Pallet as PalletCommon, Event as CommonEvent, CollectionHandle,36	eth::collection_id_to_address,37};38use pallet_structure::{Pallet as PalletStructure, Error as StructureError};39use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};40use sp_core::H160;41use sp_runtime::{ArithmeticError, DispatchError, DispatchResult, TransactionOutcome};42use sp_std::{vec::Vec, vec, collections::btree_map::BTreeMap, collections::btree_set::BTreeSet};43use core::ops::Deref;44use codec::{Encode, Decode, MaxEncodedLen};45use scale_info::TypeInfo;4647pub use pallet::*;48use weights::WeightInfo;49#[cfg(feature = "runtime-benchmarks")]50pub mod benchmarking;51pub mod common;52pub mod erc;53pub mod weights;5455pub type CreateItemData<T> = CreateNftExData<<T as pallet_evm::account::Config>::CrossAccountId>;56pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;5758#[struct_versioning::versioned(version = 2, upper)]59#[derive(Encode, Decode, TypeInfo, MaxEncodedLen)]60pub struct ItemData<CrossAccountId> {61	#[version(..2)]62	pub const_data: BoundedVec<u8, CustomDataLimit>,6364	#[version(..2)]65	pub variable_data: BoundedVec<u8, CustomDataLimit>,6667	pub owner: CrossAccountId,68}6970#[frame_support::pallet]71pub mod pallet {72	use super::*;73	use frame_support::{74		Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key, traits::StorageVersion,75	};76	use frame_system::pallet_prelude::*;77	use up_data_structs::{CollectionId, TokenId};78	use super::weights::WeightInfo;7980	#[pallet::error]81	pub enum Error<T> {82		/// Not Nonfungible item data used to mint in Nonfungible collection.83		NotNonfungibleDataUsedToMintFungibleCollectionToken,84		/// Used amount > 1 with NFT85		NonfungibleItemsHaveNoAmount,86		/// Unable to burn NFT with children87		CantBurnNftWithChildren,88	}8990	#[pallet::config]91	pub trait Config:92		frame_system::Config + pallet_common::Config + pallet_structure::Config + pallet_evm::Config93	{94		type WeightInfo: WeightInfo;95	}9697	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);9899	#[pallet::pallet]100	#[pallet::storage_version(STORAGE_VERSION)]101	#[pallet::generate_store(pub(super) trait Store)]102	pub struct Pallet<T>(_);103104	#[pallet::storage]105	pub type TokensMinted<T: Config> =106		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;107	#[pallet::storage]108	pub type TokensBurnt<T: Config> =109		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;110111	#[pallet::storage]112	pub type TokenData<T: Config> = StorageNMap<113		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),114		Value = ItemData<T::CrossAccountId>,115		QueryKind = OptionQuery,116	>;117118	#[pallet::storage]119	#[pallet::getter(fn token_properties)]120	pub type TokenProperties<T: Config> = StorageNMap<121		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),122		Value = Properties,123		QueryKind = ValueQuery,124		OnEmpty = up_data_structs::TokenProperties,125	>;126127	/// Used to enumerate tokens owned by account128	#[pallet::storage]129	pub type Owned<T: Config> = StorageNMap<130		Key = (131			Key<Twox64Concat, CollectionId>,132			Key<Blake2_128Concat, T::CrossAccountId>,133			Key<Twox64Concat, TokenId>,134		),135		Value = bool,136		QueryKind = ValueQuery,137	>;138139	/// Used to enumerate token's children140	#[pallet::storage]141	#[pallet::getter(fn token_children)]142	pub type TokenChildren<T: Config> = StorageNMap<143		Key = (144			Key<Twox64Concat, CollectionId>,145			Key<Twox64Concat, TokenId>,146			Key<Twox64Concat, (CollectionId, TokenId)>,147		),148		Value = bool,149		QueryKind = ValueQuery,150	>;151152	#[pallet::storage]153	pub type AccountBalance<T: Config> = StorageNMap<154		Key = (155			Key<Twox64Concat, CollectionId>,156			Key<Blake2_128Concat, T::CrossAccountId>,157		),158		Value = u32,159		QueryKind = ValueQuery,160	>;161162	#[pallet::storage]163	pub type Allowance<T: Config> = StorageNMap<164		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),165		Value = T::CrossAccountId,166		QueryKind = OptionQuery,167	>;168169	#[pallet::hooks]170	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {171		fn on_runtime_upgrade() -> Weight {172			if StorageVersion::get::<Pallet<T>>() < StorageVersion::new(1) {173				let mut had_consts = BTreeSet::new();174				<TokenData<T>>::translate::<ItemDataVersion1<T::CrossAccountId>, _>(175					|(collection, token), v| {176						let mut props = vec![];177						if !v.const_data.is_empty() {178							props.push(Property {179								key: b"_old_constData".to_vec().try_into().unwrap(),180								value: v181									.const_data182									.clone()183									.into_inner()184									.try_into()185									.expect("const too long"),186							});187							had_consts.insert(collection);188						}189						if !v.variable_data.is_empty() {190							props.push(Property {191								key: b"_old_variableData".to_vec().try_into().unwrap(),192								value: v193									.variable_data194									.clone()195									.into_inner()196									.try_into()197									.expect("variable too long"),198							})199						}200						if !props.is_empty() {201							Self::set_scoped_token_properties(202								collection,203								token,204								PropertyScope::None,205								props.into_iter(),206							)207							.expect("existing token data exceeds property storage");208						}209						Some(<ItemDataVersion2<T::CrossAccountId>>::from(v))210					},211				);212				for collection in had_consts {213					<PalletCommon<T>>::set_property_permission_unchecked(214						collection,215						PropertyKeyPermission {216							key: b"_old_constData".to_vec().try_into().unwrap(),217							permission: PropertyPermission {218								mutable: false,219								collection_admin: true,220								token_owner: false,221							},222						},223					)224					.expect("failed to configure permission");225				}226			}227228			0229		}230	}231}232233pub struct NonfungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);234impl<T: Config> NonfungibleHandle<T> {235	pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {236		Self(inner)237	}238	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {239		self.0240	}241	pub fn common_mut(&mut self) -> &mut pallet_common::CollectionHandle<T> {242		&mut self.0243	}244}245impl<T: Config> WithRecorder<T> for NonfungibleHandle<T> {246	fn recorder(&self) -> &SubstrateRecorder<T> {247		self.0.recorder()248	}249	fn into_recorder(self) -> SubstrateRecorder<T> {250		self.0.into_recorder()251	}252}253impl<T: Config> Deref for NonfungibleHandle<T> {254	type Target = pallet_common::CollectionHandle<T>;255256	fn deref(&self) -> &Self::Target {257		&self.0258	}259}260261impl<T: Config> Pallet<T> {262	pub fn total_supply(collection: &NonfungibleHandle<T>) -> u32 {263		<TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)264	}265	pub fn token_exists(collection: &NonfungibleHandle<T>, token: TokenId) -> bool {266		<TokenData<T>>::contains_key((collection.id, token))267	}268269	pub fn set_scoped_token_property(270		collection_id: CollectionId,271		token_id: TokenId,272		scope: PropertyScope,273		property: Property,274	) -> DispatchResult {275		TokenProperties::<T>::try_mutate((collection_id, token_id), |properties| {276			properties.try_scoped_set(scope, property.key, property.value)277		})278		.map_err(<CommonError<T>>::from)?;279280		Ok(())281	}282283	pub fn set_scoped_token_properties(284		collection_id: CollectionId,285		token_id: TokenId,286		scope: PropertyScope,287		properties: impl Iterator<Item = Property>,288	) -> DispatchResult {289		TokenProperties::<T>::try_mutate((collection_id, token_id), |stored_properties| {290			stored_properties.try_scoped_set_from_iter(scope, properties)291		})292		.map_err(<CommonError<T>>::from)?;293294		Ok(())295	}296297	pub fn current_token_id(collection_id: CollectionId) -> TokenId {298		TokenId(<TokensMinted<T>>::get(collection_id))299	}300}301302// unchecked calls skips any permission checks303impl<T: Config> Pallet<T> {304	pub fn init_collection(305		owner: T::CrossAccountId,306		data: CreateCollectionData<T::AccountId>,307	) -> Result<CollectionId, DispatchError> {308		<PalletCommon<T>>::init_collection(owner, data)309	}310	pub fn destroy_collection(311		collection: NonfungibleHandle<T>,312		sender: &T::CrossAccountId,313	) -> DispatchResult {314		let id = collection.id;315316		if Self::collection_has_tokens(id) {317			return Err(<CommonError<T>>::CantDestroyNotEmptyCollection.into());318		}319320		// =========321322		PalletCommon::destroy_collection(collection.0, sender)?;323324		<TokenData<T>>::remove_prefix((id,), None);325		<TokenChildren<T>>::remove_prefix((id,), None);326		<Owned<T>>::remove_prefix((id,), None);327		<TokensMinted<T>>::remove(id);328		<TokensBurnt<T>>::remove(id);329		<Allowance<T>>::remove_prefix((id,), None);330		<AccountBalance<T>>::remove_prefix((id,), None);331		Ok(())332	}333334	pub fn burn(335		collection: &NonfungibleHandle<T>,336		sender: &T::CrossAccountId,337		token: TokenId,338	) -> DispatchResult {339		collection.check_is_mutable()?;340341		let token_data =342			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;343		ensure!(344			&token_data.owner == sender345				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(sender)),346			<CommonError<T>>::NoPermission347		);348349		if collection.permissions.access() == AccessMode::AllowList {350			collection.check_allowlist(sender)?;351		}352353		if Self::token_has_children(collection.id, token) {354			return Err(<Error<T>>::CantBurnNftWithChildren.into());355		}356357		let burnt = <TokensBurnt<T>>::get(collection.id)358			.checked_add(1)359			.ok_or(ArithmeticError::Overflow)?;360361		let balance = <AccountBalance<T>>::get((collection.id, token_data.owner.clone()))362			.checked_sub(1)363			.ok_or(ArithmeticError::Overflow)?;364365		// =========366367		if balance == 0 {368			<AccountBalance<T>>::remove((collection.id, token_data.owner.clone()));369		} else {370			<AccountBalance<T>>::insert((collection.id, token_data.owner.clone()), balance);371		}372373		<PalletStructure<T>>::unnest_if_nested(&token_data.owner, collection.id, token);374375		<Owned<T>>::remove((collection.id, &token_data.owner, token));376		<TokensBurnt<T>>::insert(collection.id, burnt);377		<TokenData<T>>::remove((collection.id, token));378		<TokenProperties<T>>::remove((collection.id, token));379		let old_spender = <Allowance<T>>::take((collection.id, token));380381		if let Some(old_spender) = old_spender {382			<PalletCommon<T>>::deposit_event(CommonEvent::Approved(383				collection.id,384				token,385				token_data.owner.clone(),386				old_spender,387				0,388			));389		}390391		<PalletEvm<T>>::deposit_log(392			ERC721Events::Transfer {393				from: *token_data.owner.as_eth(),394				to: H160::default(),395				token_id: token.into(),396			}397			.to_log(collection_id_to_address(collection.id)),398		);399		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(400			collection.id,401			token,402			token_data.owner,403			1,404		));405		Ok(())406	}407408	#[transactional]409	pub fn burn_recursively(410		collection: &NonfungibleHandle<T>,411		sender: &T::CrossAccountId,412		token: TokenId,413		self_budget: &dyn Budget,414		breadth_budget: &dyn Budget,415	) -> DispatchResultWithPostInfo {416		ensure!(self_budget.consume(), <StructureError<T>>::DepthLimit,);417418		let current_token_account =419			T::CrossTokenAddressMapping::token_to_address(collection.id, token);420421		let mut weight = 0 as Weight;422423		// This method is transactional, if user in fact doesn't have permissions to remove token -424		// tokens removed here will be restored after rejected transaction425		for ((collection, token), _) in <TokenChildren<T>>::iter_prefix((collection.id, token)) {426			ensure!(breadth_budget.consume(), <StructureError<T>>::BreadthLimit,);427			let PostDispatchInfo { actual_weight, .. } =428				<PalletStructure<T>>::burn_item_recursively(429					current_token_account.clone(),430					collection,431					token,432					self_budget,433					breadth_budget,434				)?;435			if let Some(actual_weight) = actual_weight {436				weight = weight.saturating_add(actual_weight);437			}438		}439440		Self::burn(collection, sender, token)?;441		DispatchResultWithPostInfo::Ok(PostDispatchInfo {442			actual_weight: Some(weight + <SelfWeightOf<T>>::burn_item()),443			pays_fee: Pays::Yes,444		})445	}446447	pub fn set_token_property(448		collection: &NonfungibleHandle<T>,449		sender: &T::CrossAccountId,450		token_id: TokenId,451		property: Property,452		is_token_create: bool,453	) -> DispatchResult {454		Self::check_token_change_permission(455			collection,456			sender,457			token_id,458			&property.key,459			is_token_create,460		)?;461		collection.check_is_mutable()?;462463		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {464			let property = property.clone();465			properties.try_set(property.key, property.value)466		})467		.map_err(<CommonError<T>>::from)?;468469		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertySet(470			collection.id,471			token_id,472			property.key,473		));474475		Ok(())476	}477478	#[transactional]479	pub fn set_token_properties(480		collection: &NonfungibleHandle<T>,481		sender: &T::CrossAccountId,482		token_id: TokenId,483		properties: Vec<Property>,484		is_token_create: bool,485	) -> DispatchResult {486		for property in properties {487			Self::set_token_property(collection, sender, token_id, property, is_token_create)?;488		}489490		Ok(())491	}492493	pub fn delete_token_property(494		collection: &NonfungibleHandle<T>,495		sender: &T::CrossAccountId,496		token_id: TokenId,497		property_key: PropertyKey,498	) -> DispatchResult {499		collection.check_is_mutable()?;500		Self::check_token_change_permission(collection, sender, token_id, &property_key, false)?;501502		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {503			properties.remove(&property_key)504		})505		.map_err(<CommonError<T>>::from)?;506507		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertyDeleted(508			collection.id,509			token_id,510			property_key,511		));512513		Ok(())514	}515516	fn check_token_change_permission(517		collection: &NonfungibleHandle<T>,518		sender: &T::CrossAccountId,519		token_id: TokenId,520		property_key: &PropertyKey,521		is_token_create: bool,522	) -> DispatchResult {523		let permission = <PalletCommon<T>>::property_permissions(collection.id)524			.get(property_key)525			.cloned()526			.unwrap_or_else(PropertyPermission::none);527528		let token_data = <TokenData<T>>::get((collection.id, token_id))529			.ok_or(<CommonError<T>>::TokenNotFound)?;530531		let check_token_owner = || -> DispatchResult {532			ensure!(&token_data.owner == sender, <CommonError<T>>::NoPermission);533			Ok(())534		};535536		let is_property_exists = TokenProperties::<T>::get((collection.id, token_id))537			.get(property_key)538			.is_some();539540		match permission {541			PropertyPermission { mutable: false, .. } if is_property_exists => {542				Err(<CommonError<T>>::NoPermission.into())543			}544545			PropertyPermission {546				collection_admin,547				token_owner,548				..549			} => {550				//TODO: investigate threats during public minting.551				if is_token_create && (collection_admin || token_owner) {552					return Ok(());553				}554555				let mut check_result = Err(<CommonError<T>>::NoPermission.into());556557				if collection_admin {558					check_result = collection.check_is_owner_or_admin(sender);559				}560561				if token_owner {562					check_result.or_else(|_| check_token_owner())563				} else {564					check_result565				}566			}567		}568	}569570	#[transactional]571	pub fn delete_token_properties(572		collection: &NonfungibleHandle<T>,573		sender: &T::CrossAccountId,574		token_id: TokenId,575		property_keys: Vec<PropertyKey>,576	) -> DispatchResult {577		collection.check_is_mutable()?;578579		for key in property_keys {580			Self::delete_token_property(collection, sender, token_id, key)?;581		}582583		Ok(())584	}585586	pub fn set_collection_properties(587		collection: &NonfungibleHandle<T>,588		sender: &T::CrossAccountId,589		properties: Vec<Property>,590	) -> DispatchResult {591		<PalletCommon<T>>::set_collection_properties(collection, sender, properties)592	}593594	pub fn delete_collection_properties(595		collection: &CollectionHandle<T>,596		sender: &T::CrossAccountId,597		property_keys: Vec<PropertyKey>,598	) -> DispatchResult {599		<PalletCommon<T>>::delete_collection_properties(collection, sender, property_keys)600	}601602	pub fn set_property_permissions(603		collection: &CollectionHandle<T>,604		sender: &T::CrossAccountId,605		property_permissions: Vec<PropertyKeyPermission>,606	) -> DispatchResult {607		<PalletCommon<T>>::set_property_permissions(collection, sender, property_permissions)608	}609610	pub fn set_property_permission(611		collection: &CollectionHandle<T>,612		sender: &T::CrossAccountId,613		permission: PropertyKeyPermission,614	) -> DispatchResult {615		<PalletCommon<T>>::set_property_permission(collection, sender, permission)616	}617618	pub fn transfer(619		collection: &NonfungibleHandle<T>,620		from: &T::CrossAccountId,621		to: &T::CrossAccountId,622		token: TokenId,623		nesting_budget: &dyn Budget,624	) -> DispatchResult {625		collection.check_is_mutable()?;626627		ensure!(628			collection.limits.transfers_enabled(),629			<CommonError<T>>::TransferNotAllowed630		);631632		let token_data =633			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;634		// TODO: require sender to be token, owner, require admins to go through transfer_from635		ensure!(636			&token_data.owner == from637				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(from)),638			<CommonError<T>>::NoPermission639		);640641		if collection.permissions.access() == AccessMode::AllowList {642			collection.check_allowlist(from)?;643			collection.check_allowlist(to)?;644		}645		<PalletCommon<T>>::ensure_correct_receiver(to)?;646647		let balance_from = <AccountBalance<T>>::get((collection.id, from))648			.checked_sub(1)649			.ok_or(<CommonError<T>>::TokenValueTooLow)?;650		let balance_to = if from != to {651			let balance_to = <AccountBalance<T>>::get((collection.id, to))652				.checked_add(1)653				.ok_or(ArithmeticError::Overflow)?;654655			ensure!(656				balance_to < collection.limits.account_token_ownership_limit(),657				<CommonError<T>>::AccountTokenLimitExceeded,658			);659660			Some(balance_to)661		} else {662			None663		};664665		<PalletStructure<T>>::nest_if_sent_to_token(666			from.clone(),667			to,668			collection.id,669			token,670			nesting_budget,671		)?;672673		// =========674675		<PalletStructure<T>>::unnest_if_nested(&token_data.owner, collection.id, token);676677		<TokenData<T>>::insert(678			(collection.id, token),679			ItemData {680				owner: to.clone(),681				..token_data682			},683		);684685		if let Some(balance_to) = balance_to {686			// from != to687			if balance_from == 0 {688				<AccountBalance<T>>::remove((collection.id, from));689			} else {690				<AccountBalance<T>>::insert((collection.id, from), balance_from);691			}692			<AccountBalance<T>>::insert((collection.id, to), balance_to);693			<Owned<T>>::remove((collection.id, from, token));694			<Owned<T>>::insert((collection.id, to, token), true);695		}696		Self::set_allowance_unchecked(collection, from, token, None, true);697698		<PalletEvm<T>>::deposit_log(699			ERC721Events::Transfer {700				from: *from.as_eth(),701				to: *to.as_eth(),702				token_id: token.into(),703			}704			.to_log(collection_id_to_address(collection.id)),705		);706		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(707			collection.id,708			token,709			from.clone(),710			to.clone(),711			1,712		));713		Ok(())714	}715716	pub fn create_multiple_items(717		collection: &NonfungibleHandle<T>,718		sender: &T::CrossAccountId,719		data: Vec<CreateItemData<T>>,720		nesting_budget: &dyn Budget,721	) -> DispatchResult {722		if !collection.is_owner_or_admin(sender) {723			ensure!(724				collection.permissions.mint_mode(),725				<CommonError<T>>::PublicMintingNotAllowed726			);727			collection.check_allowlist(sender)?;728729			for item in data.iter() {730				collection.check_allowlist(&item.owner)?;731			}732		}733734		for data in data.iter() {735			<PalletCommon<T>>::ensure_correct_receiver(&data.owner)?;736		}737738		let first_token = <TokensMinted<T>>::get(collection.id);739		let tokens_minted = first_token740			.checked_add(data.len() as u32)741			.ok_or(ArithmeticError::Overflow)?;742		ensure!(743			tokens_minted <= collection.limits.token_limit(),744			<CommonError<T>>::CollectionTokenLimitExceeded745		);746747		let mut balances = BTreeMap::new();748		for data in &data {749			let balance = balances750				.entry(&data.owner)751				.or_insert_with(|| <AccountBalance<T>>::get((collection.id, &data.owner)));752			*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;753754			ensure!(755				*balance <= collection.limits.account_token_ownership_limit(),756				<CommonError<T>>::AccountTokenLimitExceeded,757			);758		}759760		for (i, data) in data.iter().enumerate() {761			let token = TokenId(first_token + i as u32 + 1);762763			<PalletStructure<T>>::check_nesting(764				sender.clone(),765				&data.owner,766				collection.id,767				token,768				nesting_budget,769			)?;770		}771772		// =========773774		with_transaction(|| {775			for (i, data) in data.iter().enumerate() {776				let token = first_token + i as u32 + 1;777778				<TokenData<T>>::insert(779					(collection.id, token),780					ItemData {781						// const_data: data.const_data.clone(),782						owner: data.owner.clone(),783					},784				);785786				<PalletStructure<T>>::nest_if_sent_to_token_unchecked(787					&data.owner,788					collection.id,789					TokenId(token),790				);791792				if let Err(e) = Self::set_token_properties(793					collection,794					sender,795					TokenId(token),796					data.properties.clone().into_inner(),797					true,798				) {799					return TransactionOutcome::Rollback(Err(e));800				}801			}802			TransactionOutcome::Commit(Ok(()))803		})?;804805		<TokensMinted<T>>::insert(collection.id, tokens_minted);806		for (account, balance) in balances {807			<AccountBalance<T>>::insert((collection.id, account), balance);808		}809		for (i, data) in data.into_iter().enumerate() {810			let token = first_token + i as u32 + 1;811			<Owned<T>>::insert((collection.id, &data.owner, token), true);812813			<PalletEvm<T>>::deposit_log(814				ERC721Events::Transfer {815					from: H160::default(),816					to: *data.owner.as_eth(),817					token_id: token.into(),818				}819				.to_log(collection_id_to_address(collection.id)),820			);821			<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(822				collection.id,823				TokenId(token),824				data.owner.clone(),825				1,826			));827		}828		Ok(())829	}830831	pub fn set_allowance_unchecked(832		collection: &NonfungibleHandle<T>,833		sender: &T::CrossAccountId,834		token: TokenId,835		spender: Option<&T::CrossAccountId>,836		assume_implicit_eth: bool,837	) {838		if let Some(spender) = spender {839			let old_spender = <Allowance<T>>::get((collection.id, token));840			<Allowance<T>>::insert((collection.id, token), spender);841			// In ERC721 there is only one possible approved user of token, so we set842			// approved user to spender843			<PalletEvm<T>>::deposit_log(844				ERC721Events::Approval {845					owner: *sender.as_eth(),846					approved: *spender.as_eth(),847					token_id: token.into(),848				}849				.to_log(collection_id_to_address(collection.id)),850			);851			// In Unique chain, any token can have any amount of approved users, so we need to852			// set allowance of old owner to 0, and allowance of new owner to 1853			if old_spender.as_ref() != Some(spender) {854				if let Some(old_owner) = old_spender {855					<PalletCommon<T>>::deposit_event(CommonEvent::Approved(856						collection.id,857						token,858						sender.clone(),859						old_owner,860						0,861					));862				}863				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(864					collection.id,865					token,866					sender.clone(),867					spender.clone(),868					1,869				));870			}871		} else {872			let old_spender = <Allowance<T>>::take((collection.id, token));873			if !assume_implicit_eth {874				// In ERC721 there is only one possible approved user of token, so we set875				// approved user to zero address876				<PalletEvm<T>>::deposit_log(877					ERC721Events::Approval {878						owner: *sender.as_eth(),879						approved: H160::default(),880						token_id: token.into(),881					}882					.to_log(collection_id_to_address(collection.id)),883				);884			}885			// In Unique chain, any token can have any amount of approved users, so we need to886			// set allowance of old owner to 0887			if let Some(old_spender) = old_spender {888				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(889					collection.id,890					token,891					sender.clone(),892					old_spender,893					0,894				));895			}896		}897	}898899	pub fn set_allowance(900		collection: &NonfungibleHandle<T>,901		sender: &T::CrossAccountId,902		token: TokenId,903		spender: Option<&T::CrossAccountId>,904	) -> DispatchResult {905		collection.check_is_mutable()?;906907		if collection.permissions.access() == AccessMode::AllowList {908			collection.check_allowlist(sender)?;909			if let Some(spender) = spender {910				collection.check_allowlist(spender)?;911			}912		}913914		if let Some(spender) = spender {915			<PalletCommon<T>>::ensure_correct_receiver(spender)?;916		}917918		let token_data =919			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;920		if &token_data.owner != sender {921			ensure!(922				collection.ignores_owned_amount(sender),923				<CommonError<T>>::CantApproveMoreThanOwned924			);925		}926927		// =========928929		Self::set_allowance_unchecked(collection, sender, token, spender, false);930		Ok(())931	}932933	fn check_allowed(934		collection: &NonfungibleHandle<T>,935		spender: &T::CrossAccountId,936		from: &T::CrossAccountId,937		token: TokenId,938		nesting_budget: &dyn Budget,939	) -> DispatchResult {940		if spender.conv_eq(from) {941			return Ok(());942		}943		if collection.permissions.access() == AccessMode::AllowList {944			// `from`, `to` checked in [`transfer`]945			collection.check_allowlist(spender)?;946		}947		if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {948			// TODO: should collection owner be allowed to perform this transfer?949			ensure!(950				<PalletStructure<T>>::check_indirectly_owned(951					spender.clone(),952					source.0,953					source.1,954					None,955					nesting_budget956				)?,957				<CommonError<T>>::ApprovedValueTooLow,958			);959			return Ok(());960		}961		if <Allowance<T>>::get((collection.id, token)).as_ref() == Some(spender) {962			return Ok(());963		}964		ensure!(965			collection.ignores_allowance(spender),966			<CommonError<T>>::ApprovedValueTooLow967		);968		Ok(())969	}970971	pub fn transfer_from(972		collection: &NonfungibleHandle<T>,973		spender: &T::CrossAccountId,974		from: &T::CrossAccountId,975		to: &T::CrossAccountId,976		token: TokenId,977		nesting_budget: &dyn Budget,978	) -> DispatchResult {979		Self::check_allowed(collection, spender, from, token, nesting_budget)?;980981		// =========982983		// Allowance is reset in [`transfer`]984		Self::transfer(collection, from, to, token, nesting_budget)985	}986987	pub fn burn_from(988		collection: &NonfungibleHandle<T>,989		spender: &T::CrossAccountId,990		from: &T::CrossAccountId,991		token: TokenId,992		nesting_budget: &dyn Budget,993	) -> DispatchResult {994		Self::check_allowed(collection, spender, from, token, nesting_budget)?;995996		// =========997998		Self::burn(collection, from, token)999	}10001001	pub fn check_nesting(1002		handle: &NonfungibleHandle<T>,1003		sender: T::CrossAccountId,1004		from: (CollectionId, TokenId),1005		under: TokenId,1006		nesting_budget: &dyn Budget,1007	) -> DispatchResult {1008		fn ensure_sender_allowed<T: Config>(1009			collection: CollectionId,1010			token: TokenId,1011			for_nest: (CollectionId, TokenId),1012			sender: T::CrossAccountId,1013			budget: &dyn Budget,1014		) -> DispatchResult {1015			ensure!(1016				<PalletStructure<T>>::check_indirectly_owned(1017					sender,1018					collection,1019					token,1020					Some(for_nest),1021					budget1022				)?,1023				<CommonError<T>>::OnlyOwnerAllowedToNest,1024			);1025			Ok(())1026		}1027		match handle.permissions.nesting() {1028			NestingRule::Disabled => fail!(<CommonError<T>>::NestingIsDisabled),1029			NestingRule::Owner => {1030				ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?1031			}1032			NestingRule::OwnerRestricted(whitelist) => {1033				ensure!(1034					whitelist.contains(&from.0),1035					<CommonError<T>>::SourceCollectionIsNotAllowedToNest1036				);1037				ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?1038			}1039			NestingRule::Permissive => {}1040		}1041		Ok(())1042	}10431044	fn nest(under: (CollectionId, TokenId), to_nest: (CollectionId, TokenId)) {1045		<TokenChildren<T>>::insert((under.0, under.1, (to_nest.0, to_nest.1)), true);1046	}10471048	fn unnest(under: (CollectionId, TokenId), to_unnest: (CollectionId, TokenId)) {1049		<TokenChildren<T>>::remove((under.0, under.1, to_unnest));1050	}10511052	fn collection_has_tokens(collection_id: CollectionId) -> bool {1053		<TokenData<T>>::iter_prefix((collection_id,))1054			.next()1055			.is_some()1056	}10571058	fn token_has_children(collection_id: CollectionId, token_id: TokenId) -> bool {1059		<TokenChildren<T>>::iter_prefix((collection_id, token_id))1060			.next()1061			.is_some()1062	}10631064	pub fn token_children_ids(collection_id: CollectionId, token_id: TokenId) -> Vec<TokenChild> {1065		<TokenChildren<T>>::iter_prefix((collection_id, token_id))1066			.map(|((child_collection_id, child_id), _)| TokenChild {1067				collection: child_collection_id,1068				token: child_id,1069			})1070			.collect()1071	}10721073	/// Delegated to `create_multiple_items`1074	pub fn create_item(1075		collection: &NonfungibleHandle<T>,1076		sender: &T::CrossAccountId,1077		data: CreateItemData<T>,1078		nesting_budget: &dyn Budget,1079	) -> DispatchResult {1080		Self::create_multiple_items(collection, sender, vec![data], nesting_budget)1081	}1082}