git.delta.rocks / unique-network / refs/commits / 6edd3f1acfd3

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};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#[struct_versioning::versioned(version = 2, upper)]53#[derive(Encode, Decode, TypeInfo, MaxEncodedLen)]54pub struct ItemData<CrossAccountId> {55	pub const_data: BoundedVec<u8, CustomDataLimit>,5657	#[version(..2)]58	pub variable_data: BoundedVec<u8, CustomDataLimit>,5960	pub owner: CrossAccountId,61}6263#[frame_support::pallet]64pub mod pallet {65	use super::*;66	use frame_support::{Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key, traits::StorageVersion};67	use frame_system::pallet_prelude::*;68	use up_data_structs::{CollectionId, TokenId};69	use super::weights::WeightInfo;7071	#[pallet::error]72	pub enum Error<T> {73		/// Not Nonfungible item data used to mint in Nonfungible collection.74		NotNonfungibleDataUsedToMintFungibleCollectionToken,75		/// Used amount > 1 with NFT76		NonfungibleItemsHaveNoAmount,77	}7879	#[pallet::config]80	pub trait Config:81		frame_system::Config + pallet_common::Config + pallet_structure::Config + pallet_evm::Config82	{83		type WeightInfo: WeightInfo;84	}8586	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);8788	#[pallet::pallet]89	#[pallet::storage_version(STORAGE_VERSION)]90	#[pallet::generate_store(pub(super) trait Store)]91	pub struct Pallet<T>(_);9293	#[pallet::storage]94	pub type TokensMinted<T: Config> =95		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;96	#[pallet::storage]97	pub type TokensBurnt<T: Config> =98		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;99100	#[pallet::storage]101	pub type TokenData<T: Config> = StorageNMap<102		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),103		Value = ItemData<T::CrossAccountId>,104		QueryKind = OptionQuery,105	>;106107	#[pallet::storage]108	#[pallet::getter(fn token_properties)]109	pub type TokenProperties<T: Config> = StorageNMap<110		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),111		Value = Properties,112		QueryKind = ValueQuery,113		OnEmpty = up_data_structs::TokenProperties,114	>;115116	/// Used to enumerate tokens owned by account117	#[pallet::storage]118	pub type Owned<T: Config> = StorageNMap<119		Key = (120			Key<Twox64Concat, CollectionId>,121			Key<Blake2_128Concat, T::CrossAccountId>,122			Key<Twox64Concat, TokenId>,123		),124		Value = bool,125		QueryKind = ValueQuery,126	>;127128	#[pallet::storage]129	pub type AccountBalance<T: Config> = StorageNMap<130		Key = (131			Key<Twox64Concat, CollectionId>,132			Key<Blake2_128Concat, T::CrossAccountId>,133		),134		Value = u32,135		QueryKind = ValueQuery,136	>;137138	#[pallet::storage]139	pub type Allowance<T: Config> = StorageNMap<140		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),141		Value = T::CrossAccountId,142		QueryKind = OptionQuery,143	>;144145	#[pallet::hooks]146	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {147		fn on_runtime_upgrade() -> Weight {148			if StorageVersion::get::<Pallet<T>>() < StorageVersion::new(1) {149				<TokenData<T>>::translate_values::<ItemDataVersion1<T::CrossAccountId>, _>(|v| {150					Some(<ItemDataVersion2<T::CrossAccountId>>::from(v))151				})152			}153154			0155		}156	}157}158159pub struct NonfungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);160impl<T: Config> NonfungibleHandle<T> {161	pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {162		Self(inner)163	}164	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {165		self.0166	}167	pub fn common_mut(&mut self) -> &mut pallet_common::CollectionHandle<T> {168		&mut self.0169	}170}171impl<T: Config> WithRecorder<T> for NonfungibleHandle<T> {172	fn recorder(&self) -> &SubstrateRecorder<T> {173		self.0.recorder()174	}175	fn into_recorder(self) -> SubstrateRecorder<T> {176		self.0.into_recorder()177	}178}179impl<T: Config> Deref for NonfungibleHandle<T> {180	type Target = pallet_common::CollectionHandle<T>;181182	fn deref(&self) -> &Self::Target {183		&self.0184	}185}186187impl<T: Config> Pallet<T> {188	pub fn total_supply(collection: &NonfungibleHandle<T>) -> u32 {189		<TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)190	}191	pub fn token_exists(collection: &NonfungibleHandle<T>, token: TokenId) -> bool {192		<TokenData<T>>::contains_key((collection.id, token))193	}194}195196// unchecked calls skips any permission checks197impl<T: Config> Pallet<T> {198	pub fn init_collection(199		owner: T::AccountId,200		data: CreateCollectionData<T::AccountId>,201	) -> Result<CollectionId, DispatchError> {202		<PalletCommon<T>>::init_collection(owner, data)203	}204	pub fn destroy_collection(205		collection: NonfungibleHandle<T>,206		sender: &T::CrossAccountId,207	) -> DispatchResult {208		let id = collection.id;209210		// =========211212		PalletCommon::destroy_collection(collection.0, sender)?;213214		<TokenData<T>>::remove_prefix((id,), None);215		<Owned<T>>::remove_prefix((id,), None);216		<TokensMinted<T>>::remove(id);217		<TokensBurnt<T>>::remove(id);218		<Allowance<T>>::remove_prefix((id,), None);219		<AccountBalance<T>>::remove_prefix((id,), None);220		Ok(())221	}222223	pub fn burn(224		collection: &NonfungibleHandle<T>,225		sender: &T::CrossAccountId,226		token: TokenId,227	) -> DispatchResult {228		let token_data =229			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;230		ensure!(231			&token_data.owner == sender232				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(sender)),233			<CommonError<T>>::NoPermission234		);235236		if collection.access == AccessMode::AllowList {237			collection.check_allowlist(sender)?;238		}239240		let burnt = <TokensBurnt<T>>::get(collection.id)241			.checked_add(1)242			.ok_or(ArithmeticError::Overflow)?;243244		let balance = <AccountBalance<T>>::get((collection.id, token_data.owner.clone()))245			.checked_sub(1)246			.ok_or(ArithmeticError::Overflow)?;247248		if balance == 0 {249			<AccountBalance<T>>::remove((collection.id, token_data.owner.clone()));250		} else {251			<AccountBalance<T>>::insert((collection.id, token_data.owner.clone()), balance);252		}253		// =========254255		<Owned<T>>::remove((collection.id, &token_data.owner, token));256		<TokensBurnt<T>>::insert(collection.id, burnt);257		<TokenData<T>>::remove((collection.id, token));258		let old_spender = <Allowance<T>>::take((collection.id, token));259260		if let Some(old_spender) = old_spender {261			<PalletCommon<T>>::deposit_event(CommonEvent::Approved(262				collection.id,263				token,264				sender.clone(),265				old_spender,266				0,267			));268		}269270		<PalletEvm<T>>::deposit_log(271			ERC721Events::Transfer {272				from: *token_data.owner.as_eth(),273				to: H160::default(),274				token_id: token.into(),275			}276			.to_log(collection_id_to_address(collection.id)),277		);278		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(279			collection.id,280			token,281			token_data.owner,282			1,283		));284		Ok(())285	}286287	pub fn set_token_property(288		collection: &NonfungibleHandle<T>,289		sender: &T::CrossAccountId,290		token_id: TokenId,291		property: Property,292	) -> DispatchResult {293		Self::check_token_change_permission(collection, sender, token_id, &property.key)?;294295		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {296			let property = property.clone();297			properties.try_set(property.key, property.value)298		})299		.map_err(<CommonError<T>>::from)?;300301		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertySet(302			collection.id,303			token_id,304			property.key,305		));306307		Ok(())308	}309310	#[transactional]311	pub fn set_token_properties(312		collection: &NonfungibleHandle<T>,313		sender: &T::CrossAccountId,314		token_id: TokenId,315		properties: Vec<Property>,316	) -> DispatchResult {317		for property in properties {318			Self::set_token_property(collection, sender, token_id, property)?;319		}320321		Ok(())322	}323324	pub fn delete_token_property(325		collection: &NonfungibleHandle<T>,326		sender: &T::CrossAccountId,327		token_id: TokenId,328		property_key: PropertyKey,329	) -> DispatchResult {330		Self::check_token_change_permission(collection, sender, token_id, &property_key)?;331332		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {333			properties.remove(&property_key)334		})335		.map_err(<CommonError<T>>::from)?;336337		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertyDeleted(338			collection.id,339			token_id,340			property_key,341		));342343		Ok(())344	}345346	fn check_token_change_permission(347		collection: &NonfungibleHandle<T>,348		sender: &T::CrossAccountId,349		token_id: TokenId,350		property_key: &PropertyKey,351	) -> DispatchResult {352		let permission = <PalletCommon<T>>::property_permissions(collection.id)353			.get(property_key)354			.map(|p| p.clone())355			.unwrap_or(PropertyPermission::none());356357		let token_data = <TokenData<T>>::get((collection.id, token_id))358			.ok_or(<CommonError<T>>::TokenNotFound)?;359360		let check_token_owner = || -> DispatchResult {361			ensure!(&token_data.owner == sender, <CommonError<T>>::NoPermission);362			Ok(())363		};364365		let is_property_exists = TokenProperties::<T>::get((collection.id, token_id))366			.get(property_key)367			.is_some();368369		match permission {370			PropertyPermission { mutable: false, .. } if is_property_exists => {371				Err(<CommonError<T>>::NoPermission.into())372			}373374			PropertyPermission {375				collection_admin,376				token_owner,377				..378			} => {379				let mut check_result = Err(<CommonError<T>>::NoPermission.into());380381				if collection_admin {382					check_result = collection.check_is_owner_or_admin(sender);383				}384385				if token_owner {386					check_result.or_else(|_| check_token_owner())387				} else {388					check_result389				}390			}391		}392	}393394	#[transactional]395	pub fn delete_token_properties(396		collection: &NonfungibleHandle<T>,397		sender: &T::CrossAccountId,398		token_id: TokenId,399		property_keys: Vec<PropertyKey>,400	) -> DispatchResult {401		for key in property_keys {402			Self::delete_token_property(collection, sender, token_id, key)?;403		}404405		Ok(())406	}407408	pub fn set_collection_properties(409		collection: &NonfungibleHandle<T>,410		sender: &T::CrossAccountId,411		properties: Vec<Property>,412	) -> DispatchResult {413		<PalletCommon<T>>::set_collection_properties(collection, sender, properties)414	}415416	pub fn delete_collection_properties(417		collection: &CollectionHandle<T>,418		sender: &T::CrossAccountId,419		property_keys: Vec<PropertyKey>,420	) -> DispatchResult {421		<PalletCommon<T>>::delete_collection_properties(collection, sender, property_keys)422	}423424	pub fn set_property_permissions(425		collection: &CollectionHandle<T>,426		sender: &T::CrossAccountId,427		property_permissions: Vec<PropertyKeyPermission>,428	) -> DispatchResult {429		<PalletCommon<T>>::set_property_permissions(collection, sender, property_permissions)430	}431432	pub fn transfer(433		collection: &NonfungibleHandle<T>,434		from: &T::CrossAccountId,435		to: &T::CrossAccountId,436		token: TokenId,437		nesting_budget: &dyn Budget,438	) -> DispatchResult {439		ensure!(440			collection.limits.transfers_enabled(),441			<CommonError<T>>::TransferNotAllowed442		);443444		let token_data =445			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;446		// TODO: require sender to be token, owner, require admins to go through transfer_from447		ensure!(448			&token_data.owner == from449				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(from)),450			<CommonError<T>>::NoPermission451		);452453		if collection.access == AccessMode::AllowList {454			collection.check_allowlist(from)?;455			collection.check_allowlist(to)?;456		}457		<PalletCommon<T>>::ensure_correct_receiver(to)?;458459		let balance_from = <AccountBalance<T>>::get((collection.id, from))460			.checked_sub(1)461			.ok_or(<CommonError<T>>::TokenValueTooLow)?;462		let balance_to = if from != to {463			let balance_to = <AccountBalance<T>>::get((collection.id, to))464				.checked_add(1)465				.ok_or(ArithmeticError::Overflow)?;466467			ensure!(468				balance_to < collection.limits.account_token_ownership_limit(),469				<CommonError<T>>::AccountTokenLimitExceeded,470			);471472			Some(balance_to)473		} else {474			None475		};476477		if let Some(target) = T::CrossTokenAddressMapping::address_to_token(to) {478			let handle = <CollectionHandle<T>>::try_get(target.0)?;479			let dispatch = T::CollectionDispatch::dispatch(handle);480			let dispatch = dispatch.as_dyn();481482			dispatch.check_nesting(483				from.clone(),484				(collection.id, token),485				target.1,486				nesting_budget,487			)?;488		}489490		// =========491492		<TokenData<T>>::insert(493			(collection.id, token),494			ItemData {495				owner: to.clone(),496				..token_data497			},498		);499500		if let Some(balance_to) = balance_to {501			// from != to502			if balance_from == 0 {503				<AccountBalance<T>>::remove((collection.id, from));504			} else {505				<AccountBalance<T>>::insert((collection.id, from), balance_from);506			}507			<AccountBalance<T>>::insert((collection.id, to), balance_to);508			<Owned<T>>::remove((collection.id, from, token));509			<Owned<T>>::insert((collection.id, to, token), true);510		}511		Self::set_allowance_unchecked(collection, from, token, None, true);512513		<PalletEvm<T>>::deposit_log(514			ERC721Events::Transfer {515				from: *from.as_eth(),516				to: *to.as_eth(),517				token_id: token.into(),518			}519			.to_log(collection_id_to_address(collection.id)),520		);521		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(522			collection.id,523			token,524			from.clone(),525			to.clone(),526			1,527		));528		Ok(())529	}530531	pub fn create_multiple_items(532		collection: &NonfungibleHandle<T>,533		sender: &T::CrossAccountId,534		data: Vec<CreateItemData<T>>,535		nesting_budget: &dyn Budget,536	) -> DispatchResult {537		if !collection.is_owner_or_admin(sender) {538			ensure!(539				collection.mint_mode,540				<CommonError<T>>::PublicMintingNotAllowed541			);542			collection.check_allowlist(sender)?;543544			for item in data.iter() {545				collection.check_allowlist(&item.owner)?;546			}547		}548549		for data in data.iter() {550			<PalletCommon<T>>::ensure_correct_receiver(&data.owner)?;551		}552553		let first_token = <TokensMinted<T>>::get(collection.id);554		let tokens_minted = first_token555			.checked_add(data.len() as u32)556			.ok_or(ArithmeticError::Overflow)?;557		ensure!(558			tokens_minted <= collection.limits.token_limit(),559			<CommonError<T>>::CollectionTokenLimitExceeded560		);561562		let mut balances = BTreeMap::new();563		for data in &data {564			let balance = balances565				.entry(&data.owner)566				.or_insert_with(|| <AccountBalance<T>>::get((collection.id, &data.owner)));567			*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;568569			ensure!(570				*balance <= collection.limits.account_token_ownership_limit(),571				<CommonError<T>>::AccountTokenLimitExceeded,572			);573		}574575		for (i, data) in data.iter().enumerate() {576			let token = TokenId(first_token + i as u32 + 1);577			if let Some(target) = T::CrossTokenAddressMapping::address_to_token(&data.owner) {578				let handle = <CollectionHandle<T>>::try_get(target.0)?;579				let dispatch = T::CollectionDispatch::dispatch(handle);580				let dispatch = dispatch.as_dyn();581				dispatch.check_nesting(582					sender.clone(),583					(collection.id, token),584					target.1,585					nesting_budget,586				)?;587			}588		}589590		// =========591592		<TokensMinted<T>>::insert(collection.id, tokens_minted);593		for (account, balance) in balances {594			<AccountBalance<T>>::insert((collection.id, account), balance);595		}596		for (i, data) in data.into_iter().enumerate() {597			let token = first_token + i as u32 + 1;598599			<TokenData<T>>::insert(600				(collection.id, token),601				ItemData {602					const_data: data.const_data,603					owner: data.owner.clone(),604				},605			);606			<Owned<T>>::insert((collection.id, &data.owner, token), true);607608			Self::set_token_properties(609				collection,610				sender,611				TokenId(token),612				data.properties.into_inner(),613			)?;614615			<PalletEvm<T>>::deposit_log(616				ERC721Events::Transfer {617					from: H160::default(),618					to: *data.owner.as_eth(),619					token_id: token.into(),620				}621				.to_log(collection_id_to_address(collection.id)),622			);623			<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(624				collection.id,625				TokenId(token),626				data.owner.clone(),627				1,628			));629		}630		Ok(())631	}632633	pub fn set_allowance_unchecked(634		collection: &NonfungibleHandle<T>,635		sender: &T::CrossAccountId,636		token: TokenId,637		spender: Option<&T::CrossAccountId>,638		assume_implicit_eth: bool,639	) {640		if let Some(spender) = spender {641			let old_spender = <Allowance<T>>::get((collection.id, token));642			<Allowance<T>>::insert((collection.id, token), spender);643			// In ERC721 there is only one possible approved user of token, so we set644			// approved user to spender645			<PalletEvm<T>>::deposit_log(646				ERC721Events::Approval {647					owner: *sender.as_eth(),648					approved: *spender.as_eth(),649					token_id: token.into(),650				}651				.to_log(collection_id_to_address(collection.id)),652			);653			// In Unique chain, any token can have any amount of approved users, so we need to654			// set allowance of old owner to 0, and allowance of new owner to 1655			if old_spender.as_ref() != Some(spender) {656				if let Some(old_owner) = old_spender {657					<PalletCommon<T>>::deposit_event(CommonEvent::Approved(658						collection.id,659						token,660						sender.clone(),661						old_owner,662						0,663					));664				}665				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(666					collection.id,667					token,668					sender.clone(),669					spender.clone(),670					1,671				));672			}673		} else {674			let old_spender = <Allowance<T>>::take((collection.id, token));675			if !assume_implicit_eth {676				// In ERC721 there is only one possible approved user of token, so we set677				// approved user to zero address678				<PalletEvm<T>>::deposit_log(679					ERC721Events::Approval {680						owner: *sender.as_eth(),681						approved: H160::default(),682						token_id: token.into(),683					}684					.to_log(collection_id_to_address(collection.id)),685				);686			}687			// In Unique chain, any token can have any amount of approved users, so we need to688			// set allowance of old owner to 0689			if let Some(old_spender) = old_spender {690				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(691					collection.id,692					token,693					sender.clone(),694					old_spender,695					0,696				));697			}698		}699	}700701	pub fn set_allowance(702		collection: &NonfungibleHandle<T>,703		sender: &T::CrossAccountId,704		token: TokenId,705		spender: Option<&T::CrossAccountId>,706	) -> DispatchResult {707		if collection.access == AccessMode::AllowList {708			collection.check_allowlist(sender)?;709			if let Some(spender) = spender {710				collection.check_allowlist(spender)?;711			}712		}713714		if let Some(spender) = spender {715			<PalletCommon<T>>::ensure_correct_receiver(spender)?;716		}717		let token_data =718			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;719		if &token_data.owner != sender {720			ensure!(721				collection.ignores_owned_amount(sender),722				<CommonError<T>>::CantApproveMoreThanOwned723			);724		}725726		// =========727728		Self::set_allowance_unchecked(collection, sender, token, spender, false);729		Ok(())730	}731732	fn check_allowed(733		collection: &NonfungibleHandle<T>,734		spender: &T::CrossAccountId,735		from: &T::CrossAccountId,736		token: TokenId,737		nesting_budget: &dyn Budget,738	) -> DispatchResult {739		if spender.conv_eq(from) {740			return Ok(());741		}742		if collection.access == AccessMode::AllowList {743			// `from`, `to` checked in [`transfer`]744			collection.check_allowlist(spender)?;745		}746		if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {747			// TODO: should collection owner be allowed to perform this transfer?748			ensure!(749				<PalletStructure<T>>::check_indirectly_owned(750					spender.clone(),751					source.0,752					source.1,753					None,754					nesting_budget755				)?,756				<CommonError<T>>::ApprovedValueTooLow,757			);758			return Ok(());759		}760		if <Allowance<T>>::get((collection.id, token)).as_ref() == Some(spender) {761			return Ok(());762		}763		ensure!(764			collection.ignores_allowance(spender),765			<CommonError<T>>::ApprovedValueTooLow766		);767		Ok(())768	}769770	pub fn transfer_from(771		collection: &NonfungibleHandle<T>,772		spender: &T::CrossAccountId,773		from: &T::CrossAccountId,774		to: &T::CrossAccountId,775		token: TokenId,776		nesting_budget: &dyn Budget,777	) -> DispatchResult {778		Self::check_allowed(collection, spender, from, token, nesting_budget)?;779780		// =========781782		// Allowance is reset in [`transfer`]783		Self::transfer(collection, from, to, token, nesting_budget)784	}785786	pub fn burn_from(787		collection: &NonfungibleHandle<T>,788		spender: &T::CrossAccountId,789		from: &T::CrossAccountId,790		token: TokenId,791		nesting_budget: &dyn Budget,792	) -> DispatchResult {793		Self::check_allowed(collection, spender, from, token, nesting_budget)?;794795		// =========796797		Self::burn(collection, from, token)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}