git.delta.rocks / unique-network / refs/commits / fe4e7633ea11

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};22use up_data_structs::{23	AccessMode, CollectionId, CustomDataLimit, TokenId, CreateCollectionData, CreateNftExData,24	mapping::TokenAddressMapping, NestingRule, budget::Budget, Property, PropertyPermission,25	PropertyKey, PropertyKeyPermission, Properties, TrySet,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};36use sp_std::{vec::Vec, vec};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#[derive(Encode, Decode, TypeInfo, MaxEncodedLen)]53pub struct ItemData<CrossAccountId> {54	pub const_data: BoundedVec<u8, CustomDataLimit>,55	pub variable_data: BoundedVec<u8, CustomDataLimit>,56	pub owner: CrossAccountId,57}5859#[frame_support::pallet]60pub mod pallet {61	use super::*;62	use frame_support::{Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key};63	use up_data_structs::{CollectionId, TokenId};64	use super::weights::WeightInfo;6566	#[pallet::error]67	pub enum Error<T> {68		/// Not Nonfungible item data used to mint in Nonfungible collection.69		NotNonfungibleDataUsedToMintFungibleCollectionToken,70		/// Used amount > 1 with NFT71		NonfungibleItemsHaveNoAmount,72	}7374	#[pallet::config]75	pub trait Config:76		frame_system::Config + pallet_common::Config + pallet_structure::Config + pallet_evm::Config77	{78		type WeightInfo: WeightInfo;79	}8081	#[pallet::pallet]82	#[pallet::generate_store(pub(super) trait Store)]83	pub struct Pallet<T>(_);8485	#[pallet::storage]86	pub type TokensMinted<T: Config> =87		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;88	#[pallet::storage]89	pub type TokensBurnt<T: Config> =90		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;9192	#[pallet::storage]93	pub type TokenData<T: Config> = StorageNMap<94		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),95		Value = ItemData<T::CrossAccountId>,96		QueryKind = OptionQuery,97	>;9899	#[pallet::storage]100	#[pallet::getter(fn token_properties)]101	pub type TokenProperties<T: Config> = StorageNMap<102		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),103		Value = Properties,104		QueryKind = ValueQuery,105		OnEmpty = up_data_structs::TokenProperties,106	>;107108	/// Used to enumerate tokens owned by account109	#[pallet::storage]110	pub type Owned<T: Config> = StorageNMap<111		Key = (112			Key<Twox64Concat, CollectionId>,113			Key<Blake2_128Concat, T::CrossAccountId>,114			Key<Twox64Concat, TokenId>,115		),116		Value = bool,117		QueryKind = ValueQuery,118	>;119120	#[pallet::storage]121	pub type AccountBalance<T: Config> = StorageNMap<122		Key = (123			Key<Twox64Concat, CollectionId>,124			Key<Blake2_128Concat, T::CrossAccountId>,125		),126		Value = u32,127		QueryKind = ValueQuery,128	>;129130	#[pallet::storage]131	pub type Allowance<T: Config> = StorageNMap<132		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),133		Value = T::CrossAccountId,134		QueryKind = OptionQuery,135	>;136}137138pub struct NonfungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);139impl<T: Config> NonfungibleHandle<T> {140	pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {141		Self(inner)142	}143	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {144		self.0145	}146	pub fn common_mut(&mut self) -> &mut pallet_common::CollectionHandle<T> {147		&mut self.0148	}149}150impl<T: Config> WithRecorder<T> for NonfungibleHandle<T> {151	fn recorder(&self) -> &SubstrateRecorder<T> {152		self.0.recorder()153	}154	fn into_recorder(self) -> SubstrateRecorder<T> {155		self.0.into_recorder()156	}157}158impl<T: Config> Deref for NonfungibleHandle<T> {159	type Target = pallet_common::CollectionHandle<T>;160161	fn deref(&self) -> &Self::Target {162		&self.0163	}164}165166impl<T: Config> Pallet<T> {167	pub fn total_supply(collection: &NonfungibleHandle<T>) -> u32 {168		<TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)169	}170	pub fn token_exists(collection: &NonfungibleHandle<T>, token: TokenId) -> bool {171		<TokenData<T>>::contains_key((collection.id, token))172	}173}174175// unchecked calls skips any permission checks176impl<T: Config> Pallet<T> {177	pub fn init_collection(178		owner: T::AccountId,179		data: CreateCollectionData<T::AccountId>,180	) -> Result<CollectionId, DispatchError> {181		<PalletCommon<T>>::init_collection(owner, data)182	}183	pub fn destroy_collection(184		collection: NonfungibleHandle<T>,185		sender: &T::CrossAccountId,186	) -> DispatchResult {187		let id = collection.id;188189		// =========190191		PalletCommon::destroy_collection(collection.0, sender)?;192193		<TokenData<T>>::remove_prefix((id,), None);194		<Owned<T>>::remove_prefix((id,), None);195		<TokensMinted<T>>::remove(id);196		<TokensBurnt<T>>::remove(id);197		<Allowance<T>>::remove_prefix((id,), None);198		<AccountBalance<T>>::remove_prefix((id,), None);199		Ok(())200	}201202	pub fn burn(203		collection: &NonfungibleHandle<T>,204		sender: &T::CrossAccountId,205		token: TokenId,206	) -> DispatchResult {207		let token_data =208			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;209		ensure!(210			&token_data.owner == sender211				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(sender)),212			<CommonError<T>>::NoPermission213		);214215		if collection.access == AccessMode::AllowList {216			collection.check_allowlist(sender)?;217		}218219		let burnt = <TokensBurnt<T>>::get(collection.id)220			.checked_add(1)221			.ok_or(ArithmeticError::Overflow)?;222223		let balance = <AccountBalance<T>>::get((collection.id, token_data.owner.clone()))224			.checked_sub(1)225			.ok_or(ArithmeticError::Overflow)?;226227		if balance == 0 {228			<AccountBalance<T>>::remove((collection.id, token_data.owner.clone()));229		} else {230			<AccountBalance<T>>::insert((collection.id, token_data.owner.clone()), balance);231		}232		// =========233234		<Owned<T>>::remove((collection.id, &token_data.owner, token));235		<TokensBurnt<T>>::insert(collection.id, burnt);236		<TokenData<T>>::remove((collection.id, token));237		let old_spender = <Allowance<T>>::take((collection.id, token));238239		if let Some(old_spender) = old_spender {240			<PalletCommon<T>>::deposit_event(CommonEvent::Approved(241				collection.id,242				token,243				sender.clone(),244				old_spender,245				0,246			));247		}248249		<PalletEvm<T>>::deposit_log(250			ERC721Events::Transfer {251				from: *token_data.owner.as_eth(),252				to: H160::default(),253				token_id: token.into(),254			}255			.to_log(collection_id_to_address(collection.id)),256		);257		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(258			collection.id,259			token,260			token_data.owner,261			1,262		));263		Ok(())264	}265266	pub fn set_token_property(267		collection: &NonfungibleHandle<T>,268		sender: &T::CrossAccountId,269		token_id: TokenId,270		property: Property,271	) -> DispatchResult {272		Self::check_token_change_permission(collection, sender, token_id, &property.key)?;273274		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {275			let property = property.clone();276			properties.try_set(property.key, property.value)277		})278		.map_err(<CommonError<T>>::from)?;279280		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertySet(281			collection.id,282			token_id,283			property.key,284		));285286		Ok(())287	}288289	pub fn set_token_properties(290		collection: &NonfungibleHandle<T>,291		sender: &T::CrossAccountId,292		token_id: TokenId,293		properties: Vec<Property>,294	) -> DispatchResult {295		for property in properties {296			Self::set_token_property(collection, sender, token_id, property)?;297		}298299		Ok(())300	}301302	pub fn delete_token_property(303		collection: &NonfungibleHandle<T>,304		sender: &T::CrossAccountId,305		token_id: TokenId,306		property_key: PropertyKey,307	) -> DispatchResult {308		Self::check_token_change_permission(collection, sender, token_id, &property_key)?;309310		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {311			properties.remove(&property_key)312		})313		.map_err(<CommonError<T>>::from)?;314315		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertyDeleted(316			collection.id,317			token_id,318			property_key,319		));320321		Ok(())322	}323324	fn check_token_change_permission(325		collection: &NonfungibleHandle<T>,326		sender: &T::CrossAccountId,327		token_id: TokenId,328		property_key: &PropertyKey,329	) -> DispatchResult {330		let permission = <PalletCommon<T>>::property_permissions(collection.id)331			.get(property_key)332			.map(|p| p.clone())333			.unwrap_or(PropertyPermission::none());334335		let token_data = <TokenData<T>>::get((collection.id, token_id))336			.ok_or(<CommonError<T>>::TokenNotFound)?;337338		let check_token_owner = || -> DispatchResult {339			ensure!(&token_data.owner == sender, <CommonError<T>>::NoPermission);340			Ok(())341		};342343		let is_property_exists = TokenProperties::<T>::get((collection.id, token_id))344			.get(property_key)345			.is_some();346347		match permission {348			PropertyPermission { mutable: false, .. } if is_property_exists => {349				Err(<CommonError<T>>::NoPermission.into())350			}351352			PropertyPermission {353				collection_admin,354				token_owner,355				..356			} => {357				let mut check_result = Err(<CommonError<T>>::NoPermission.into());358359				if collection_admin {360					check_result = collection.check_is_owner_or_admin(sender);361				}362363				if token_owner {364					check_result.and_then(|()| check_token_owner())365				} else {366					check_result367				}368			}369		}370	}371372	pub fn delete_token_properties(373		collection: &NonfungibleHandle<T>,374		sender: &T::CrossAccountId,375		token_id: TokenId,376		property_keys: Vec<PropertyKey>,377	) -> DispatchResult {378		for key in property_keys {379			Self::delete_token_property(collection, sender, token_id, key)?;380		}381382		Ok(())383	}384385	pub fn set_collection_properties(386		collection: &NonfungibleHandle<T>,387		sender: &T::CrossAccountId,388		properties: Vec<Property>,389	) -> DispatchResult {390		<PalletCommon<T>>::set_collection_properties(collection, sender, properties)391	}392393	pub fn delete_collection_properties(394		collection: &CollectionHandle<T>,395		sender: &T::CrossAccountId,396		property_keys: Vec<PropertyKey>,397	) -> DispatchResult {398		<PalletCommon<T>>::delete_collection_properties(collection, sender, property_keys)399	}400401	pub fn set_property_permissions(402		collection: &CollectionHandle<T>,403		sender: &T::CrossAccountId,404		property_permissions: Vec<PropertyKeyPermission>,405	) -> DispatchResult {406		<PalletCommon<T>>::set_property_permissions(collection, sender, property_permissions)407	}408409	pub fn transfer(410		collection: &NonfungibleHandle<T>,411		from: &T::CrossAccountId,412		to: &T::CrossAccountId,413		token: TokenId,414		nesting_budget: &dyn Budget,415	) -> DispatchResult {416		ensure!(417			collection.limits.transfers_enabled(),418			<CommonError<T>>::TransferNotAllowed419		);420421		let token_data =422			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;423		// TODO: require sender to be token, owner, require admins to go through transfer_from424		ensure!(425			&token_data.owner == from426				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(from)),427			<CommonError<T>>::NoPermission428		);429430		if collection.access == AccessMode::AllowList {431			collection.check_allowlist(from)?;432			collection.check_allowlist(to)?;433		}434		<PalletCommon<T>>::ensure_correct_receiver(to)?;435436		let balance_from = <AccountBalance<T>>::get((collection.id, from))437			.checked_sub(1)438			.ok_or(<CommonError<T>>::TokenValueTooLow)?;439		let balance_to = if from != to {440			let balance_to = <AccountBalance<T>>::get((collection.id, to))441				.checked_add(1)442				.ok_or(ArithmeticError::Overflow)?;443444			ensure!(445				balance_to < collection.limits.account_token_ownership_limit(),446				<CommonError<T>>::AccountTokenLimitExceeded,447			);448449			Some(balance_to)450		} else {451			None452		};453454		if let Some(target) = T::CrossTokenAddressMapping::address_to_token(to) {455			let handle = <CollectionHandle<T>>::try_get(target.0)?;456			let dispatch = T::CollectionDispatch::dispatch(handle);457			let dispatch = dispatch.as_dyn();458459			dispatch.check_nesting(460				from.clone(),461				(collection.id, token),462				target.1,463				nesting_budget,464			)?;465		}466467		// =========468469		<TokenData<T>>::insert(470			(collection.id, token),471			ItemData {472				owner: to.clone(),473				..token_data474			},475		);476477		if let Some(balance_to) = balance_to {478			// from != to479			if balance_from == 0 {480				<AccountBalance<T>>::remove((collection.id, from));481			} else {482				<AccountBalance<T>>::insert((collection.id, from), balance_from);483			}484			<AccountBalance<T>>::insert((collection.id, to), balance_to);485			<Owned<T>>::remove((collection.id, from, token));486			<Owned<T>>::insert((collection.id, to, token), true);487		}488		Self::set_allowance_unchecked(collection, from, token, None, true);489490		<PalletEvm<T>>::deposit_log(491			ERC721Events::Transfer {492				from: *from.as_eth(),493				to: *to.as_eth(),494				token_id: token.into(),495			}496			.to_log(collection_id_to_address(collection.id)),497		);498		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(499			collection.id,500			token,501			from.clone(),502			to.clone(),503			1,504		));505		Ok(())506	}507508	pub fn create_multiple_items(509		collection: &NonfungibleHandle<T>,510		sender: &T::CrossAccountId,511		data: Vec<CreateItemData<T>>,512		nesting_budget: &dyn Budget,513	) -> DispatchResult {514		if !collection.is_owner_or_admin(sender) {515			ensure!(516				collection.mint_mode,517				<CommonError<T>>::PublicMintingNotAllowed518			);519			collection.check_allowlist(sender)?;520521			for item in data.iter() {522				collection.check_allowlist(&item.owner)?;523			}524		}525526		for data in data.iter() {527			<PalletCommon<T>>::ensure_correct_receiver(&data.owner)?;528		}529530		let first_token = <TokensMinted<T>>::get(collection.id);531		let tokens_minted = first_token532			.checked_add(data.len() as u32)533			.ok_or(ArithmeticError::Overflow)?;534		ensure!(535			tokens_minted <= collection.limits.token_limit(),536			<CommonError<T>>::CollectionTokenLimitExceeded537		);538539		let mut balances = BTreeMap::new();540		for data in &data {541			let balance = balances542				.entry(&data.owner)543				.or_insert_with(|| <AccountBalance<T>>::get((collection.id, &data.owner)));544			*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;545546			ensure!(547				*balance <= collection.limits.account_token_ownership_limit(),548				<CommonError<T>>::AccountTokenLimitExceeded,549			);550		}551552		for (i, data) in data.iter().enumerate() {553			let token = TokenId(first_token + i as u32 + 1);554			if let Some(target) = T::CrossTokenAddressMapping::address_to_token(&data.owner) {555				let handle = <CollectionHandle<T>>::try_get(target.0)?;556				let dispatch = T::CollectionDispatch::dispatch(handle);557				let dispatch = dispatch.as_dyn();558				dispatch.check_nesting(559					sender.clone(),560					(collection.id, token),561					target.1,562					nesting_budget,563				)?;564			}565		}566567		// =========568569		<TokensMinted<T>>::insert(collection.id, tokens_minted);570		for (account, balance) in balances {571			<AccountBalance<T>>::insert((collection.id, account), balance);572		}573		for (i, data) in data.into_iter().enumerate() {574			let token = first_token + i as u32 + 1;575576			<TokenData<T>>::insert(577				(collection.id, token),578				ItemData {579					const_data: data.const_data,580					variable_data: data.variable_data,581					owner: data.owner.clone(),582				},583			);584			<Owned<T>>::insert((collection.id, &data.owner, token), true);585586			Self::set_token_properties(587				collection,588				sender,589				TokenId(token),590				data.properties.into_inner(),591			)?;592593			<PalletEvm<T>>::deposit_log(594				ERC721Events::Transfer {595					from: H160::default(),596					to: *data.owner.as_eth(),597					token_id: token.into(),598				}599				.to_log(collection_id_to_address(collection.id)),600			);601			<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(602				collection.id,603				TokenId(token),604				data.owner.clone(),605				1,606			));607		}608		Ok(())609	}610611	pub fn set_allowance_unchecked(612		collection: &NonfungibleHandle<T>,613		sender: &T::CrossAccountId,614		token: TokenId,615		spender: Option<&T::CrossAccountId>,616		assume_implicit_eth: bool,617	) {618		if let Some(spender) = spender {619			let old_spender = <Allowance<T>>::get((collection.id, token));620			<Allowance<T>>::insert((collection.id, token), spender);621			// In ERC721 there is only one possible approved user of token, so we set622			// approved user to spender623			<PalletEvm<T>>::deposit_log(624				ERC721Events::Approval {625					owner: *sender.as_eth(),626					approved: *spender.as_eth(),627					token_id: token.into(),628				}629				.to_log(collection_id_to_address(collection.id)),630			);631			// In Unique chain, any token can have any amount of approved users, so we need to632			// set allowance of old owner to 0, and allowance of new owner to 1633			if old_spender.as_ref() != Some(spender) {634				if let Some(old_owner) = old_spender {635					<PalletCommon<T>>::deposit_event(CommonEvent::Approved(636						collection.id,637						token,638						sender.clone(),639						old_owner,640						0,641					));642				}643				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(644					collection.id,645					token,646					sender.clone(),647					spender.clone(),648					1,649				));650			}651		} else {652			let old_spender = <Allowance<T>>::take((collection.id, token));653			if !assume_implicit_eth {654				// In ERC721 there is only one possible approved user of token, so we set655				// approved user to zero address656				<PalletEvm<T>>::deposit_log(657					ERC721Events::Approval {658						owner: *sender.as_eth(),659						approved: H160::default(),660						token_id: token.into(),661					}662					.to_log(collection_id_to_address(collection.id)),663				);664			}665			// In Unique chain, any token can have any amount of approved users, so we need to666			// set allowance of old owner to 0667			if let Some(old_spender) = old_spender {668				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(669					collection.id,670					token,671					sender.clone(),672					old_spender,673					0,674				));675			}676		}677	}678679	pub fn set_allowance(680		collection: &NonfungibleHandle<T>,681		sender: &T::CrossAccountId,682		token: TokenId,683		spender: Option<&T::CrossAccountId>,684	) -> DispatchResult {685		if collection.access == AccessMode::AllowList {686			collection.check_allowlist(sender)?;687			if let Some(spender) = spender {688				collection.check_allowlist(spender)?;689			}690		}691692		if let Some(spender) = spender {693			<PalletCommon<T>>::ensure_correct_receiver(spender)?;694		}695		let token_data =696			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;697		if &token_data.owner != sender {698			ensure!(699				collection.ignores_owned_amount(sender),700				<CommonError<T>>::CantApproveMoreThanOwned701			);702		}703704		// =========705706		Self::set_allowance_unchecked(collection, sender, token, spender, false);707		Ok(())708	}709710	fn check_allowed(711		collection: &NonfungibleHandle<T>,712		spender: &T::CrossAccountId,713		from: &T::CrossAccountId,714		token: TokenId,715		nesting_budget: &dyn Budget,716	) -> DispatchResult {717		if spender.conv_eq(from) {718			return Ok(());719		}720		if collection.access == AccessMode::AllowList {721			// `from`, `to` checked in [`transfer`]722			collection.check_allowlist(spender)?;723		}724		if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {725			// TODO: should collection owner be allowed to perform this transfer?726			ensure!(727				<PalletStructure<T>>::check_indirectly_owned(728					spender.clone(),729					source.0,730					source.1,731					None,732					nesting_budget733				)?,734				<CommonError<T>>::ApprovedValueTooLow,735			);736			return Ok(());737		}738		if <Allowance<T>>::get((collection.id, token)).as_ref() == Some(spender) {739			return Ok(());740		}741		ensure!(742			collection.ignores_allowance(spender),743			<CommonError<T>>::ApprovedValueTooLow744		);745		Ok(())746	}747748	pub fn transfer_from(749		collection: &NonfungibleHandle<T>,750		spender: &T::CrossAccountId,751		from: &T::CrossAccountId,752		to: &T::CrossAccountId,753		token: TokenId,754		nesting_budget: &dyn Budget,755	) -> DispatchResult {756		Self::check_allowed(collection, spender, from, token, nesting_budget)?;757758		// =========759760		// Allowance is reset in [`transfer`]761		Self::transfer(collection, from, to, token, nesting_budget)762	}763764	pub fn burn_from(765		collection: &NonfungibleHandle<T>,766		spender: &T::CrossAccountId,767		from: &T::CrossAccountId,768		token: TokenId,769		nesting_budget: &dyn Budget,770	) -> DispatchResult {771		Self::check_allowed(collection, spender, from, token, nesting_budget)?;772773		// =========774775		Self::burn(collection, from, token)776	}777778	pub fn set_variable_metadata(779		collection: &NonfungibleHandle<T>,780		sender: &T::CrossAccountId,781		token: TokenId,782		data: BoundedVec<u8, CustomDataLimit>,783	) -> DispatchResult {784		let token_data =785			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;786		collection.check_can_update_meta(sender, &token_data.owner)?;787788		// =========789790		<TokenData<T>>::insert(791			(collection.id, token),792			ItemData {793				variable_data: data,794				..token_data795			},796		);797		Ok(())798	}799800	pub fn check_nesting(801		handle: &NonfungibleHandle<T>,802		sender: T::CrossAccountId,803		from: (CollectionId, TokenId),804		under: TokenId,805		nesting_budget: &dyn Budget,806	) -> DispatchResult {807		fn ensure_sender_allowed<T: Config>(808			collection: CollectionId,809			token: TokenId,810			for_nest: (CollectionId, TokenId),811			sender: T::CrossAccountId,812			budget: &dyn Budget,813		) -> DispatchResult {814			ensure!(815				<PalletStructure<T>>::check_indirectly_owned(816					sender,817					collection,818					token,819					Some(for_nest),820					budget821				)?,822				<CommonError<T>>::OnlyOwnerAllowedToNest,823			);824			Ok(())825		}826		match handle.limits.nesting_rule() {827			NestingRule::Disabled => fail!(<CommonError<T>>::NestingIsDisabled),828			NestingRule::Owner => {829				ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?830			}831			NestingRule::OwnerRestricted(whitelist) => {832				ensure!(833					whitelist.contains(&from.0),834					<CommonError<T>>::SourceCollectionIsNotAllowedToNest835				);836				ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?837			}838		}839		Ok(())840	}841842	/// Delegated to `create_multiple_items`843	pub fn create_item(844		collection: &NonfungibleHandle<T>,845		sender: &T::CrossAccountId,846		data: CreateItemData<T>,847		nesting_budget: &dyn Budget,848	) -> DispatchResult {849		Self::create_multiple_items(collection, sender, vec![data], nesting_budget)850	}851}