git.delta.rocks / unique-network / refs/commits / 63b9443a2b7f

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 frame_support::{pallet_prelude::*, transactional, BoundedVec, dispatch::DispatchResult};20use frame_system::{pallet_prelude::*, ensure_signed};21use sp_runtime::{DispatchError, Permill, traits::StaticLookup};22use sp_std::vec::Vec;23use up_data_structs::{*, mapping::TokenAddressMapping};24use pallet_common::{25	Pallet as PalletCommon, Error as CommonError, CollectionHandle, CommonCollectionOperations,26};27use pallet_nonfungible::{Pallet as PalletNft, NonfungibleHandle, TokenData};28use pallet_structure::{Pallet as PalletStructure, Error as StructureError};29use pallet_evm::account::CrossAccountId;30use core::convert::AsRef;3132pub use pallet::*;3334#[cfg(feature = "runtime-benchmarks")]35pub mod benchmarking;36pub mod misc;37pub mod property;38pub mod weights;3940pub type SelfWeightOf<T> = <T as Config>::WeightInfo;4142use weights::WeightInfo;43use misc::*;44pub use property::*;4546use RmrkProperty::*;4748pub const NESTING_BUDGET: u32 = 5;4950#[frame_support::pallet]51pub mod pallet {52	use super::*;53	use pallet_evm::account;5455	#[pallet::config]56	pub trait Config:57		frame_system::Config + pallet_common::Config + pallet_nonfungible::Config + account::Config58	{59		type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;60		type WeightInfo: WeightInfo;61	}6263	#[pallet::storage]64	#[pallet::getter(fn collection_index)]65	pub type CollectionIndex<T: Config> = StorageValue<_, RmrkCollectionId, ValueQuery>;6667	#[pallet::storage]68	pub type UniqueCollectionId<T: Config> =69		StorageMap<_, Twox64Concat, RmrkCollectionId, CollectionId, ValueQuery>;7071	#[pallet::pallet]72	#[pallet::generate_store(pub(super) trait Store)]73	pub struct Pallet<T>(_);7475	#[pallet::event]76	#[pallet::generate_deposit(pub(super) fn deposit_event)]77	pub enum Event<T: Config> {78		CollectionCreated {79			issuer: T::AccountId,80			collection_id: RmrkCollectionId,81		},82		CollectionDestroyed {83			issuer: T::AccountId,84			collection_id: RmrkCollectionId,85		},86		IssuerChanged {87			old_issuer: T::AccountId,88			new_issuer: T::AccountId,89			collection_id: RmrkCollectionId,90		},91		CollectionLocked {92			issuer: T::AccountId,93			collection_id: RmrkCollectionId,94		},95		NftMinted {96			owner: T::AccountId,97			collection_id: RmrkCollectionId,98			nft_id: RmrkNftId,99		},100		NFTBurned {101			owner: T::AccountId,102			nft_id: RmrkNftId,103		},104		NFTSent {105			sender: T::AccountId,106			recipient: RmrkAccountIdOrCollectionNftTuple<T::AccountId>,107			collection_id: RmrkCollectionId,108			nft_id: RmrkNftId,109			approval_required: bool,110		},111		NFTAccepted {112			sender: T::AccountId,113			recipient: RmrkAccountIdOrCollectionNftTuple<T::AccountId>,114			collection_id: RmrkCollectionId,115			nft_id: RmrkNftId,116		},117		NFTRejected {118			sender: T::AccountId,119			collection_id: RmrkCollectionId,120			nft_id: RmrkNftId,121		},122		PropertySet {123			collection_id: RmrkCollectionId,124			maybe_nft_id: Option<RmrkNftId>,125			key: RmrkKeyString,126			value: RmrkValueString,127		},128		ResourceAdded {129			nft_id: RmrkNftId,130			resource_id: RmrkResourceId,131		},132		ResourceRemoval {133			nft_id: RmrkNftId,134			resource_id: RmrkResourceId,135		},136		ResourceAccepted {137			nft_id: RmrkNftId,138			resource_id: RmrkResourceId,139		},140		ResourceRemovalAccepted {141			nft_id: RmrkNftId,142			resource_id: RmrkResourceId,143		},144		PrioritySet {145			collection_id: RmrkCollectionId,146			nft_id: RmrkNftId,147		},148	}149150	#[pallet::error]151	pub enum Error<T> {152		/* Unique-specific events */153		CorruptedCollectionType,154		NftTypeEncodeError,155		RmrkPropertyKeyIsTooLong,156		RmrkPropertyValueIsTooLong,157		UnableToDecodeRmrkData,158159		/* RMRK compatible events */160		CollectionNotEmpty,161		NoAvailableCollectionId,162		NoAvailableNftId,163		CollectionUnknown,164		NoPermission,165		NonTransferable,166		CollectionFullOrLocked,167		ResourceDoesntExist,168		CannotSendToDescendentOrSelf,169		CannotAcceptNonOwnedNft,170		CannotRejectNonOwnedNft,171		ResourceNotPending,172	}173174	#[pallet::call]175	impl<T: Config> Pallet<T> {176		/// Create a collection177		#[transactional]178		#[pallet::weight(<SelfWeightOf<T>>::create_collection())]179		pub fn create_collection(180			origin: OriginFor<T>,181			metadata: RmrkString,182			max: Option<u32>,183			symbol: RmrkCollectionSymbol,184		) -> DispatchResult {185			let sender = ensure_signed(origin)?;186187			let limits = CollectionLimits {188				owner_can_transfer: Some(false),189				token_limit: max,190				..Default::default()191			};192193			let data = CreateCollectionData {194				limits: Some(limits),195				token_prefix: symbol196					.into_inner()197					.try_into()198					.map_err(|_| <CommonError<T>>::CollectionTokenPrefixLimitExceeded)?,199				permissions: Some(CollectionPermissions {200					nesting: Some(NestingPermissions {201						token_owner: true,202						collection_admin: false,203						restricted: None,204205						permissive: false,206					}),207					..Default::default()208				}),209				..Default::default()210			};211212			let unique_collection_id = Self::init_collection(213				T::CrossAccountId::from_sub(sender.clone()),214				data,215				[216					Self::rmrk_property(Metadata, &metadata)?,217					Self::rmrk_property(CollectionType, &misc::CollectionType::Regular)?,218				]219				.into_iter(),220			)?;221			let rmrk_collection_id = <CollectionIndex<T>>::get();222223			<UniqueCollectionId<T>>::insert(rmrk_collection_id, unique_collection_id);224225			<PalletCommon<T>>::set_scoped_collection_property(226				unique_collection_id,227				PropertyScope::Rmrk,228				Self::rmrk_property(RmrkInternalCollectionId, &rmrk_collection_id)?,229			)?;230231			<CollectionIndex<T>>::mutate(|n| *n += 1);232233			Self::deposit_event(Event::CollectionCreated {234				issuer: sender,235				collection_id: rmrk_collection_id,236			});237238			Ok(())239		}240241		/// destroy collection242		#[transactional]243		#[pallet::weight(<SelfWeightOf<T>>::destroy_collection())]244		pub fn destroy_collection(245			origin: OriginFor<T>,246			collection_id: RmrkCollectionId,247		) -> DispatchResult {248			let sender = ensure_signed(origin)?;249			let cross_sender = T::CrossAccountId::from_sub(sender.clone());250251			let collection = Self::get_typed_nft_collection(252				Self::unique_collection_id(collection_id)?,253				misc::CollectionType::Regular,254			)?;255			collection.check_is_external()?;256257			<PalletNft<T>>::destroy_collection(collection, &cross_sender)258				.map_err(Self::map_unique_err_to_proxy)?;259260			Self::deposit_event(Event::CollectionDestroyed {261				issuer: sender,262				collection_id,263			});264265			Ok(())266		}267268		/// Change the issuer of a collection269		///270		/// Parameters:271		/// - `origin`: sender of the transaction272		/// - `collection_id`: collection id of the nft to change issuer of273		/// - `new_issuer`: Collection's new issuer274		#[transactional]275		#[pallet::weight(<SelfWeightOf<T>>::change_collection_issuer())]276		pub fn change_collection_issuer(277			origin: OriginFor<T>,278			collection_id: RmrkCollectionId,279			new_issuer: <T::Lookup as StaticLookup>::Source,280		) -> DispatchResult {281			let sender = ensure_signed(origin)?;282283			let collection = Self::get_nft_collection(Self::unique_collection_id(collection_id)?)?;284			collection.check_is_external()?;285286			let new_issuer = T::Lookup::lookup(new_issuer)?;287288			Self::change_collection_owner(289				Self::unique_collection_id(collection_id)?,290				misc::CollectionType::Regular,291				sender.clone(),292				new_issuer.clone(),293			)?;294295			Self::deposit_event(Event::IssuerChanged {296				old_issuer: sender,297				new_issuer,298				collection_id,299			});300301			Ok(())302		}303304		/// lock collection305		#[transactional]306		#[pallet::weight(<SelfWeightOf<T>>::lock_collection())]307		pub fn lock_collection(308			origin: OriginFor<T>,309			collection_id: RmrkCollectionId,310		) -> DispatchResult {311			let sender = ensure_signed(origin)?;312			let cross_sender = T::CrossAccountId::from_sub(sender.clone());313314			let collection = Self::get_typed_nft_collection(315				Self::unique_collection_id(collection_id)?,316				misc::CollectionType::Regular,317			)?;318			collection.check_is_external()?;319320			Self::check_collection_owner(&collection, &cross_sender)?;321322			let token_count = collection.total_supply();323324			let mut collection = collection.into_inner();325			collection.limits.token_limit = Some(token_count);326			collection.save()?;327328			Self::deposit_event(Event::CollectionLocked {329				issuer: sender,330				collection_id,331			});332333			Ok(())334		}335336		/// Mints an NFT in the specified collection337		/// Sets metadata and the royalty attribute338		///339		/// Parameters:340		/// - `collection_id`: The class of the asset to be minted.341		/// - `nft_id`: The nft value of the asset to be minted.342		/// - `recipient`: Receiver of the royalty343		/// - `royalty`: Permillage reward from each trade for the Recipient344		/// - `metadata`: Arbitrary data about an nft, e.g. IPFS hash345		/// - `transferable`: Ability to transfer this NFT346		#[transactional]347		#[pallet::weight(<SelfWeightOf<T>>::mint_nft(resources.as_ref().map(|r| r.len() as u32).unwrap_or(0)))]348		pub fn mint_nft(349			origin: OriginFor<T>,350			owner: T::AccountId,351			collection_id: RmrkCollectionId,352			recipient: Option<T::AccountId>,353			royalty_amount: Option<Permill>,354			metadata: RmrkString,355			transferable: bool,356			resources: Option<BoundedVec<RmrkResourceTypes, MaxResourcesOnMint>>,357		) -> DispatchResult {358			let sender = ensure_signed(origin)?;359			let cross_sender = T::CrossAccountId::from_sub(sender.clone());360			let cross_owner = T::CrossAccountId::from_sub(owner.clone());361362			let collection = Self::get_typed_nft_collection(363				Self::unique_collection_id(collection_id)?,364				misc::CollectionType::Regular,365			)?;366			collection.check_is_external()?;367368			let royalty_info = royalty_amount.map(|amount| rmrk_traits::RoyaltyInfo {369				recipient: recipient.unwrap_or_else(|| owner.clone()),370				amount,371			});372373			let nft_id = Self::create_nft(374				&cross_sender,375				&cross_owner,376				&collection,377				[378					Self::rmrk_property(TokenType, &NftType::Regular)?,379					Self::rmrk_property(Transferable, &transferable)?,380					Self::rmrk_property(PendingNftAccept, &false)?,381					Self::rmrk_property(RoyaltyInfo, &royalty_info)?,382					Self::rmrk_property(Metadata, &metadata)?,383					Self::rmrk_property(Equipped, &false)?,384					Self::rmrk_property(ResourceCollection, &None::<CollectionId>)?,385					Self::rmrk_property(ResourcePriorities, &<Vec<u8>>::new())?,386				]387				.into_iter(),388			)389			.map_err(|err| match err {390				DispatchError::Arithmetic(_) => <Error<T>>::NoAvailableNftId.into(),391				err => Self::map_unique_err_to_proxy(err),392			})?;393394			if let Some(resources) = resources {395				for resource in resources {396					Self::resource_add(sender.clone(), collection.id, nft_id, resource)?;397				}398			}399400			Self::deposit_event(Event::NftMinted {401				owner,402				collection_id,403				nft_id: nft_id.0,404			});405406			Ok(())407		}408409		/// burn nft410		#[transactional]411		#[pallet::weight(<SelfWeightOf<T>>::burn_nft(*max_burns))]412		pub fn burn_nft(413			origin: OriginFor<T>,414			collection_id: RmrkCollectionId,415			nft_id: RmrkNftId,416			max_burns: u32,417		) -> DispatchResult {418			let sender = ensure_signed(origin)?;419			let cross_sender = T::CrossAccountId::from_sub(sender.clone());420421			let collection = Self::get_typed_nft_collection(422				Self::unique_collection_id(collection_id)?,423				misc::CollectionType::Regular,424			)?;425			collection.check_is_external()?;426427			Self::destroy_nft(428				cross_sender,429				Self::unique_collection_id(collection_id)?,430				nft_id.into(),431				max_burns,432				<Error<T>>::NoPermission,433			)434			.map_err(|err| Self::map_unique_err_to_proxy(err.error))?;435436			Self::deposit_event(Event::NFTBurned {437				owner: sender,438				nft_id,439			});440441			Ok(())442		}443444		/// Transfers a NFT from an Account or NFT A to another Account or NFT B445		///446		/// Parameters:447		/// - `origin`: sender of the transaction448		/// - `rmrk_collection_id`: collection id of the nft to be transferred449		/// - `rmrk_nft_id`: nft id of the nft to be transferred450		/// - `new_owner`: new owner of the nft which can be either an account or a NFT451		#[transactional]452		#[pallet::weight(<SelfWeightOf<T>>::send())]453		pub fn send(454			origin: OriginFor<T>,455			rmrk_collection_id: RmrkCollectionId,456			rmrk_nft_id: RmrkNftId,457			new_owner: RmrkAccountIdOrCollectionNftTuple<T::AccountId>,458		) -> DispatchResult {459			let sender = ensure_signed(origin.clone())?;460			let cross_sender = T::CrossAccountId::from_sub(sender.clone());461462			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;463			let nft_id = rmrk_nft_id.into();464465			let collection =466				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;467			collection.check_is_external()?;468469			let token_data =470				<TokenData<T>>::get((collection_id, nft_id)).ok_or(<Error<T>>::NoAvailableNftId)?;471472			let from = token_data.owner;473474			ensure!(475				Self::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Transferable)?,476				<Error<T>>::NonTransferable477			);478479			ensure!(480				!Self::get_nft_property_decoded(481					collection_id,482					nft_id,483					RmrkProperty::PendingNftAccept484				)?,485				<Error<T>>::NoPermission486			);487488			let target_owner;489			let approval_required;490491			match new_owner {492				RmrkAccountIdOrCollectionNftTuple::AccountId(ref account_id) => {493					target_owner = T::CrossAccountId::from_sub(account_id.clone());494					approval_required = false;495				}496				RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(497					target_collection_id,498					target_nft_id,499				) => {500					let target_collection_id = Self::unique_collection_id(target_collection_id)?;501502					let target_nft_budget = budget::Value::new(NESTING_BUDGET);503504					let target_nft_owner = <PalletStructure<T>>::get_checked_topmost_owner(505						target_collection_id,506						target_nft_id.into(),507						Some((collection_id, nft_id)),508						&target_nft_budget,509					)510					.map_err(Self::map_unique_err_to_proxy)?;511512					approval_required = cross_sender != target_nft_owner;513514					if approval_required {515						target_owner = target_nft_owner;516517						<PalletNft<T>>::set_scoped_token_property(518							collection.id,519							nft_id,520							PropertyScope::Rmrk,521							Self::rmrk_property(PendingNftAccept, &approval_required)?,522						)?;523					} else {524						target_owner = T::CrossTokenAddressMapping::token_to_address(525							target_collection_id,526							target_nft_id.into(),527						);528					}529				}530			}531532			let src_nft_budget = budget::Value::new(NESTING_BUDGET);533534			<PalletNft<T>>::transfer_from(535				&collection,536				&cross_sender,537				&from,538				&target_owner,539				nft_id,540				&src_nft_budget,541			)542			.map_err(Self::map_unique_err_to_proxy)?;543544			Self::deposit_event(Event::NFTSent {545				sender,546				recipient: new_owner,547				collection_id: rmrk_collection_id,548				nft_id: rmrk_nft_id,549				approval_required,550			});551552			Ok(())553		}554555		/// Accepts an NFT sent from another account to self or owned NFT556		///557		/// Parameters:558		/// - `origin`: sender of the transaction559		/// - `rmrk_collection_id`: collection id of the nft to be accepted560		/// - `rmrk_nft_id`: nft id of the nft to be accepted561		/// - `new_owner`: either origin's account ID or origin-owned NFT, whichever the NFT was562		///   sent to563		#[transactional]564		#[pallet::weight(<SelfWeightOf<T>>::accept_nft())]565		pub fn accept_nft(566			origin: OriginFor<T>,567			rmrk_collection_id: RmrkCollectionId,568			rmrk_nft_id: RmrkNftId,569			new_owner: RmrkAccountIdOrCollectionNftTuple<T::AccountId>,570		) -> DispatchResult {571			let sender = ensure_signed(origin.clone())?;572			let cross_sender = T::CrossAccountId::from_sub(sender.clone());573574			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;575			let nft_id = rmrk_nft_id.into();576577			let collection =578				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;579			collection.check_is_external()?;580581			let new_cross_owner = match new_owner {582				RmrkAccountIdOrCollectionNftTuple::AccountId(ref account_id) => {583					T::CrossAccountId::from_sub(account_id.clone())584				}585				RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(586					target_collection_id,587					target_nft_id,588				) => {589					let target_collection_id = Self::unique_collection_id(target_collection_id)?;590591					T::CrossTokenAddressMapping::token_to_address(592						target_collection_id,593						TokenId(target_nft_id),594					)595				}596			};597598			let budget = budget::Value::new(NESTING_BUDGET);599600			<PalletNft<T>>::transfer(601				&collection,602				&cross_sender,603				&new_cross_owner,604				nft_id,605				&budget,606			)607			.map_err(|err| {608				if err == <CommonError<T>>::UserIsNotAllowedToNest.into() {609					<Error<T>>::CannotAcceptNonOwnedNft.into()610				} else {611					Self::map_unique_err_to_proxy(err)612				}613			})?;614615			<PalletNft<T>>::set_scoped_token_property(616				collection.id,617				nft_id,618				PropertyScope::Rmrk,619				Self::rmrk_property(PendingNftAccept, &false)?,620			)?;621622			Self::deposit_event(Event::NFTAccepted {623				sender,624				recipient: new_owner,625				collection_id: rmrk_collection_id,626				nft_id: rmrk_nft_id,627			});628629			Ok(())630		}631632		/// Rejects an NFT sent from another account to self or owned NFT633		///634		/// Parameters:635		/// - `origin`: sender of the transaction636		/// - `rmrk_collection_id`: collection id of the nft to be accepted637		/// - `rmrk_nft_id`: nft id of the nft to be accepted638		#[transactional]639		#[pallet::weight(<SelfWeightOf<T>>::reject_nft())]640		pub fn reject_nft(641			origin: OriginFor<T>,642			rmrk_collection_id: RmrkCollectionId,643			rmrk_nft_id: RmrkNftId,644		) -> DispatchResult {645			let sender = ensure_signed(origin)?;646			let cross_sender = T::CrossAccountId::from_sub(sender.clone());647648			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;649			let nft_id = rmrk_nft_id.into();650651			let collection =652				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;653			collection.check_is_external()?;654655			ensure!(656				Self::get_nft_property_decoded(657					collection_id,658					nft_id,659					RmrkProperty::PendingNftAccept660				)?,661				<Error<T>>::NoPermission662			);663664			Self::destroy_nft(665				cross_sender,666				collection_id,667				nft_id,668				NESTING_BUDGET,669				<Error<T>>::CannotRejectNonOwnedNft,670			)671			.map_err(|err| Self::map_unique_err_to_proxy(err.error))?;672673			Self::deposit_event(Event::NFTRejected {674				sender,675				collection_id: rmrk_collection_id,676				nft_id: rmrk_nft_id,677			});678679			Ok(())680		}681682		/// accept the addition of a new resource to an existing NFT683		#[transactional]684		#[pallet::weight(<SelfWeightOf<T>>::accept_resource())]685		pub fn accept_resource(686			origin: OriginFor<T>,687			rmrk_collection_id: RmrkCollectionId,688			rmrk_nft_id: RmrkNftId,689			rmrk_resource_id: RmrkResourceId,690		) -> DispatchResult {691			let sender = ensure_signed(origin)?;692			let cross_sender = T::CrossAccountId::from_sub(sender);693694			let collection_id = Self::unique_collection_id(rmrk_collection_id)695				.map_err(|_| <Error<T>>::ResourceDoesntExist)?;696			let collection =697				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;698			collection.check_is_external()?;699700			let nft_id = rmrk_nft_id.into();701			let resource_id = rmrk_resource_id.into();702703			let budget = budget::Value::new(NESTING_BUDGET);704705			let nft_owner =706				<PalletStructure<T>>::find_topmost_owner(collection_id, nft_id, &budget)707					.map_err(|_| <Error<T>>::ResourceDoesntExist)?;708709			let resource_collection_id: Option<CollectionId> =710				Self::get_nft_property_decoded(collection_id, nft_id, ResourceCollection)711					.map_err(|_| <Error<T>>::ResourceDoesntExist)?;712713			let resource_collection_id =714				resource_collection_id.ok_or(<Error<T>>::ResourceDoesntExist)?;715716			let is_pending: bool = Self::get_nft_property_decoded(717				resource_collection_id,718				resource_id,719				PendingResourceAccept,720			)721			.map_err(|_| <Error<T>>::ResourceDoesntExist)?;722723			ensure!(is_pending, <Error<T>>::ResourceNotPending);724725			ensure!(cross_sender == nft_owner, <Error<T>>::NoPermission);726727			<PalletNft<T>>::set_scoped_token_property(728				resource_collection_id,729				rmrk_resource_id.into(),730				PropertyScope::Rmrk,731				Self::rmrk_property(PendingResourceAccept, &false)?,732			)?;733734			Self::deposit_event(Event::<T>::ResourceAccepted {735				nft_id: rmrk_nft_id,736				resource_id: rmrk_resource_id,737			});738739			Ok(())740		}741742		/// accept the removal of a resource of an existing NFT743		#[transactional]744		#[pallet::weight(<SelfWeightOf<T>>::accept_resource_removal())]745		pub fn accept_resource_removal(746			origin: OriginFor<T>,747			rmrk_collection_id: RmrkCollectionId,748			rmrk_nft_id: RmrkNftId,749			rmrk_resource_id: RmrkResourceId,750		) -> DispatchResult {751			let sender = ensure_signed(origin)?;752			let cross_sender = T::CrossAccountId::from_sub(sender);753754			let collection_id = Self::unique_collection_id(rmrk_collection_id)755				.map_err(|_| <Error<T>>::ResourceDoesntExist)?;756			let collection =757				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;758			collection.check_is_external()?;759760			let nft_id = rmrk_nft_id.into();761			let resource_id = rmrk_resource_id.into();762763			let budget = budget::Value::new(NESTING_BUDGET);764765			let nft_owner =766				<PalletStructure<T>>::find_topmost_owner(collection_id, nft_id, &budget)767					.map_err(|_| <Error<T>>::ResourceDoesntExist)?;768769			ensure!(cross_sender == nft_owner, <Error<T>>::NoPermission);770771			let resource_collection_id: Option<CollectionId> =772				Self::get_nft_property_decoded(collection_id, nft_id, ResourceCollection)773					.map_err(|_| <Error<T>>::ResourceDoesntExist)?;774775			let resource_collection_id =776				resource_collection_id.ok_or(<Error<T>>::ResourceDoesntExist)?;777778			let is_pending: bool = Self::get_nft_property_decoded(779				resource_collection_id,780				resource_id,781				PendingResourceRemoval,782			)783			.map_err(|_| <Error<T>>::ResourceDoesntExist)?;784785			ensure!(is_pending, <Error<T>>::ResourceNotPending);786787			let resource_collection = Self::get_typed_nft_collection(788				resource_collection_id,789				misc::CollectionType::Resource,790			)?;791792			let resource_data = <TokenData<T>>::get((resource_collection_id, resource_id))793				.ok_or(<Error<T>>::ResourceDoesntExist)?;794795			let resource_owner = resource_data.owner;796797			<PalletNft<T>>::burn(798				&resource_collection,799				&resource_owner,800				rmrk_resource_id.into(),801			)802			.map_err(Self::map_unique_err_to_proxy)?;803804			Self::deposit_event(Event::<T>::ResourceRemovalAccepted {805				nft_id: rmrk_nft_id,806				resource_id: rmrk_resource_id,807			});808809			Ok(())810		}811812		/// set a custom value on an NFT813		#[transactional]814		#[pallet::weight(<SelfWeightOf<T>>::set_property())]815		pub fn set_property(816			origin: OriginFor<T>,817			#[pallet::compact] rmrk_collection_id: RmrkCollectionId,818			maybe_nft_id: Option<RmrkNftId>,819			key: RmrkKeyString,820			value: RmrkValueString,821		) -> DispatchResult {822			let sender = ensure_signed(origin)?;823			let sender = T::CrossAccountId::from_sub(sender);824825			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;826			let collection =827				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;828			collection.check_is_external()?;829830			let budget = budget::Value::new(NESTING_BUDGET);831832			match maybe_nft_id {833				Some(nft_id) => {834					let token_id: TokenId = nft_id.into();835836					Self::ensure_nft_type(collection_id, token_id, NftType::Regular)?;837					Self::ensure_nft_owner(collection_id, token_id, &sender, &budget)?;838839					<PalletNft<T>>::set_scoped_token_property(840						collection_id,841						token_id,842						PropertyScope::Rmrk,843						Self::rmrk_property(UserProperty(key.as_slice()), &value)?,844					)?;845				}846				None => {847					let collection = Self::get_typed_nft_collection(848						collection_id,849						misc::CollectionType::Regular,850					)?;851852					Self::check_collection_owner(&collection, &sender)?;853854					<PalletCommon<T>>::set_scoped_collection_property(855						collection_id,856						PropertyScope::Rmrk,857						Self::rmrk_property(UserProperty(key.as_slice()), &value)?,858					)?;859				}860			}861862			Self::deposit_event(Event::PropertySet {863				collection_id: rmrk_collection_id,864				maybe_nft_id,865				key,866				value,867			});868869			Ok(())870		}871872		/// set a different order of resource priority873		#[transactional]874		#[pallet::weight(<SelfWeightOf<T>>::set_priority())]875		pub fn set_priority(876			origin: OriginFor<T>,877			rmrk_collection_id: RmrkCollectionId,878			rmrk_nft_id: RmrkNftId,879			priorities: BoundedVec<RmrkResourceId, RmrkMaxPriorities>,880		) -> DispatchResult {881			let sender = ensure_signed(origin)?;882			let sender = T::CrossAccountId::from_sub(sender);883884			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;885			let nft_id = rmrk_nft_id.into();886887			let collection =888				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;889			collection.check_is_external()?;890891			let budget = budget::Value::new(NESTING_BUDGET);892893			Self::ensure_nft_type(collection_id, nft_id, NftType::Regular)?;894			Self::ensure_nft_owner(collection_id, nft_id, &sender, &budget)?;895896			<PalletNft<T>>::set_scoped_token_property(897				collection_id,898				nft_id,899				PropertyScope::Rmrk,900				Self::rmrk_property(ResourcePriorities, &priorities.into_inner())?,901			)?;902903			Self::deposit_event(Event::<T>::PrioritySet {904				collection_id: rmrk_collection_id,905				nft_id: rmrk_nft_id,906			});907908			Ok(())909		}910911		/// Create basic resource912		#[transactional]913		#[pallet::weight(<SelfWeightOf<T>>::add_basic_resource())]914		pub fn add_basic_resource(915			origin: OriginFor<T>,916			rmrk_collection_id: RmrkCollectionId,917			nft_id: RmrkNftId,918			resource: RmrkBasicResource,919		) -> DispatchResult {920			let sender = ensure_signed(origin.clone())?;921922			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;923			let collection =924				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;925			collection.check_is_external()?;926927			let resource_id = Self::resource_add(928				sender,929				collection_id,930				nft_id.into(),931				RmrkResourceTypes::Basic(resource),932			)?;933934			Self::deposit_event(Event::ResourceAdded {935				nft_id,936				resource_id,937			});938			Ok(())939		}940941		/// Create composable resource942		#[transactional]943		#[pallet::weight(<SelfWeightOf<T>>::add_composable_resource())]944		pub fn add_composable_resource(945			origin: OriginFor<T>,946			rmrk_collection_id: RmrkCollectionId,947			nft_id: RmrkNftId,948			resource: RmrkComposableResource,949		) -> DispatchResult {950			let sender = ensure_signed(origin.clone())?;951952			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;953			let collection =954				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;955			collection.check_is_external()?;956957			let resource_id = Self::resource_add(958				sender,959				collection_id,960				nft_id.into(),961				RmrkResourceTypes::Composable(resource),962			)?;963964			Self::deposit_event(Event::ResourceAdded {965				nft_id,966				resource_id,967			});968			Ok(())969		}970971		/// Create slot resource972		#[transactional]973		#[pallet::weight(<SelfWeightOf<T>>::add_slot_resource())]974		pub fn add_slot_resource(975			origin: OriginFor<T>,976			rmrk_collection_id: RmrkCollectionId,977			nft_id: RmrkNftId,978			resource: RmrkSlotResource,979		) -> DispatchResult {980			let sender = ensure_signed(origin.clone())?;981982			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;983			let collection =984				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;985			collection.check_is_external()?;986987			let resource_id = Self::resource_add(988				sender,989				collection_id,990				nft_id.into(),991				RmrkResourceTypes::Slot(resource),992			)?;993994			Self::deposit_event(Event::ResourceAdded {995				nft_id,996				resource_id,997			});998			Ok(())999		}10001001		/// remove resource1002		#[transactional]1003		#[pallet::weight(<SelfWeightOf<T>>::remove_resource())]1004		pub fn remove_resource(1005			origin: OriginFor<T>,1006			rmrk_collection_id: RmrkCollectionId,1007			nft_id: RmrkNftId,1008			resource_id: RmrkResourceId,1009		) -> DispatchResult {1010			let sender = ensure_signed(origin.clone())?;10111012			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;1013			let collection =1014				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1015			collection.check_is_external()?;10161017			Self::resource_remove(sender, collection_id, nft_id.into(), resource_id.into())?;10181019			Self::deposit_event(Event::ResourceRemoval {1020				nft_id,1021				resource_id,1022			});1023			Ok(())1024		}1025	}1026}10271028impl<T: Config> Pallet<T> {1029	pub fn rmrk_property_key(rmrk_key: RmrkProperty) -> Result<PropertyKey, DispatchError> {1030		let key = rmrk_key.to_key::<T>()?;10311032		let scoped_key = PropertyScope::Rmrk1033			.apply(key)1034			.map_err(|_| <Error<T>>::RmrkPropertyKeyIsTooLong)?;10351036		Ok(scoped_key)1037	}10381039	// todo think about renaming these1040	pub fn rmrk_property<E: Encode>(1041		rmrk_key: RmrkProperty,1042		value: &E,1043	) -> Result<Property, DispatchError> {1044		let key = rmrk_key.to_key::<T>()?;10451046		let value = value1047			.encode()1048			.try_into()1049			.map_err(|_| <Error<T>>::RmrkPropertyValueIsTooLong)?;10501051		let property = Property { key, value };10521053		Ok(property)1054	}10551056	pub fn decode_property<D: Decode>(vec: PropertyValue) -> Result<D, DispatchError> {1057		vec.decode()1058			.map_err(|_| <Error<T>>::UnableToDecodeRmrkData.into())1059	}10601061	pub fn rebind<L, S>(vec: &BoundedVec<u8, L>) -> Result<BoundedVec<u8, S>, DispatchError>1062	where1063		BoundedVec<u8, S>: TryFrom<Vec<u8>>,1064	{1065		vec.rebind()1066			.map_err(|_| <Error<T>>::RmrkPropertyValueIsTooLong.into())1067	}10681069	fn init_collection(1070		sender: T::CrossAccountId,1071		data: CreateCollectionData<T::AccountId>,1072		properties: impl Iterator<Item = Property>,1073	) -> Result<CollectionId, DispatchError> {1074		let collection_id = <PalletNft<T>>::init_collection(sender, data, true);10751076		if let Err(DispatchError::Arithmetic(_)) = &collection_id {1077			return Err(<Error<T>>::NoAvailableCollectionId.into());1078		}10791080		<PalletCommon<T>>::set_scoped_collection_properties(1081			collection_id?,1082			PropertyScope::Rmrk,1083			properties,1084		)?;10851086		collection_id1087	}10881089	pub fn create_nft(1090		sender: &T::CrossAccountId,1091		owner: &T::CrossAccountId,1092		collection: &NonfungibleHandle<T>,1093		properties: impl Iterator<Item = Property>,1094	) -> Result<TokenId, DispatchError> {1095		let data = CreateNftExData {1096			properties: BoundedVec::default(),1097			owner: owner.clone(),1098		};10991100		let budget = budget::Value::new(NESTING_BUDGET);11011102		<PalletNft<T>>::create_item(collection, sender, data, &budget)?;11031104		let nft_id = <PalletNft<T>>::current_token_id(collection.id);11051106		<PalletNft<T>>::set_scoped_token_properties(1107			collection.id,1108			nft_id,1109			PropertyScope::Rmrk,1110			properties,1111		)?;11121113		Ok(nft_id)1114	}11151116	fn destroy_nft(1117		sender: T::CrossAccountId,1118		collection_id: CollectionId,1119		token_id: TokenId,1120		max_burns: u32,1121		error_if_not_owned: Error<T>,1122	) -> DispatchResultWithPostInfo {1123		let collection =1124			Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;11251126		let token_data =1127			<TokenData<T>>::get((collection_id, token_id)).ok_or(<Error<T>>::NoAvailableNftId)?;11281129		let from = token_data.owner;11301131		let owner_check_budget = budget::Value::new(NESTING_BUDGET);11321133		ensure!(1134			<PalletStructure<T>>::check_indirectly_owned(1135				sender.clone(),1136				collection_id,1137				token_id,1138				None,1139				&owner_check_budget1140			)?,1141			error_if_not_owned,1142		);11431144		let burns_budget = budget::Value::new(max_burns);1145		let breadth_budget = budget::Value::new(max_burns);11461147		<PalletNft<T>>::burn_recursively(1148			&collection,1149			&from,1150			token_id,1151			&burns_budget,1152			&breadth_budget,1153		)1154	}11551156	fn resource_add(1157		sender: T::AccountId,1158		collection_id: CollectionId,1159		nft_id: TokenId,1160		resource: RmrkResourceTypes,1161	) -> Result<RmrkResourceId, DispatchError> {1162		match resource {1163			RmrkResourceTypes::Basic(resource) => Self::resource_add_helper(1164				sender,1165				collection_id,1166				nft_id,1167				[1168					Self::rmrk_property(TokenType, &NftType::Resource)?,1169					Self::rmrk_property(ResourceType, &misc::ResourceType::Basic)?,1170					Self::rmrk_property(Src, &resource.src)?,1171					Self::rmrk_property(Metadata, &resource.metadata)?,1172					Self::rmrk_property(License, &resource.license)?,1173					Self::rmrk_property(Thumb, &resource.thumb)?,1174				]1175				.into_iter(),1176			),1177			RmrkResourceTypes::Composable(resource) => Self::resource_add_helper(1178				sender,1179				collection_id,1180				nft_id.into(),1181				[1182					Self::rmrk_property(TokenType, &NftType::Resource)?,1183					Self::rmrk_property(ResourceType, &misc::ResourceType::Composable)?,1184					Self::rmrk_property(Parts, &resource.parts)?,1185					Self::rmrk_property(Base, &resource.base)?,1186					Self::rmrk_property(Src, &resource.src)?,1187					Self::rmrk_property(Metadata, &resource.metadata)?,1188					Self::rmrk_property(License, &resource.license)?,1189					Self::rmrk_property(Thumb, &resource.thumb)?,1190				]1191				.into_iter(),1192			),1193			RmrkResourceTypes::Slot(resource) => Self::resource_add_helper(1194				sender,1195				collection_id,1196				nft_id.into(),1197				[1198					Self::rmrk_property(TokenType, &NftType::Resource)?,1199					Self::rmrk_property(ResourceType, &misc::ResourceType::Slot)?,1200					Self::rmrk_property(Base, &resource.base)?,1201					Self::rmrk_property(Src, &resource.src)?,1202					Self::rmrk_property(Metadata, &resource.metadata)?,1203					Self::rmrk_property(Slot, &resource.slot)?,1204					Self::rmrk_property(License, &resource.license)?,1205					Self::rmrk_property(Thumb, &resource.thumb)?,1206				]1207				.into_iter(),1208			),1209		}1210	}12111212	fn resource_add_helper(1213		sender: T::AccountId,1214		collection_id: CollectionId,1215		token_id: TokenId,1216		resource_properties: impl Iterator<Item = Property>,1217	) -> Result<RmrkResourceId, DispatchError> {1218		let collection =1219			Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1220		ensure!(collection.owner == sender, Error::<T>::NoPermission);12211222		let sender = T::CrossAccountId::from_sub(sender);1223		let budget = budget::Value::new(NESTING_BUDGET);12241225		let nft_owner = <PalletStructure<T>>::find_topmost_owner(collection_id, token_id, &budget)1226			.map_err(Self::map_unique_err_to_proxy)?;12271228		let pending = sender != nft_owner;12291230		let resource_collection_id: Option<CollectionId> =1231			Self::get_nft_property_decoded(collection_id, token_id, ResourceCollection)?;12321233		let resource_collection_id = match resource_collection_id {1234			Some(id) => id,1235			None => {1236				let resource_collection_id = Self::init_collection(1237					sender.clone(),1238					CreateCollectionData {1239						..Default::default()1240					},1241					[Self::rmrk_property(1242						CollectionType,1243						&misc::CollectionType::Resource,1244					)?]1245					.into_iter(),1246				)?;12471248				<PalletNft<T>>::set_scoped_token_property(1249					collection_id,1250					token_id,1251					PropertyScope::Rmrk,1252					Self::rmrk_property(ResourceCollection, &Some(resource_collection_id))?,1253				)?;12541255				resource_collection_id1256			}1257		};12581259		let resource_collection =1260			Self::get_typed_nft_collection(resource_collection_id, misc::CollectionType::Resource)?;12611262		// todo probably add extra connections to bases, slots, etc., when RMRK starts to use them12631264		let resource_id = Self::create_nft(1265			&sender,1266			&nft_owner,1267			&resource_collection,1268			resource_properties.chain(1269				[1270					Self::rmrk_property(PendingResourceAccept, &pending)?,1271					Self::rmrk_property(PendingResourceRemoval, &false)?,1272				]1273				.into_iter(),1274			),1275		)1276		.map_err(|err| match err {1277			DispatchError::Arithmetic(_) => <Error<T>>::NoAvailableNftId.into(),1278			err => Self::map_unique_err_to_proxy(err),1279		})?;12801281		Ok(resource_id.0)1282	}12831284	fn resource_remove(1285		sender: T::AccountId,1286		collection_id: CollectionId,1287		nft_id: TokenId,1288		resource_id: TokenId,1289	) -> DispatchResult {1290		let collection =1291			Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1292		ensure!(collection.owner == sender, Error::<T>::NoPermission);12931294		let resource_collection_id: Option<CollectionId> =1295			Self::get_nft_property_decoded(collection_id, nft_id, ResourceCollection)?;12961297		let resource_collection_id =1298			resource_collection_id.ok_or(Error::<T>::ResourceDoesntExist)?;12991300		let resource_collection =1301			Self::get_typed_nft_collection(resource_collection_id, misc::CollectionType::Resource)?;1302		ensure!(1303			<PalletNft<T>>::token_exists(&resource_collection, resource_id),1304			Error::<T>::ResourceDoesntExist1305		);13061307		let budget = up_data_structs::budget::Value::new(NESTING_BUDGET);1308		let topmost_owner =1309			<PalletStructure<T>>::find_topmost_owner(collection_id, nft_id, &budget)?;13101311		let sender = T::CrossAccountId::from_sub(sender);1312		if topmost_owner == sender {1313			<PalletNft<T>>::burn(&resource_collection, &sender, resource_id)1314				.map_err(Self::map_unique_err_to_proxy)?;1315		} else {1316			<PalletNft<T>>::set_scoped_token_property(1317				resource_collection_id,1318				resource_id,1319				PropertyScope::Rmrk,1320				Self::rmrk_property(PendingResourceRemoval, &true)?,1321			)?;1322		}13231324		Ok(())1325	}13261327	fn change_collection_owner(1328		collection_id: CollectionId,1329		collection_type: misc::CollectionType,1330		sender: T::AccountId,1331		new_owner: T::AccountId,1332	) -> DispatchResult {1333		let collection = Self::get_typed_nft_collection(collection_id, collection_type)?;1334		Self::check_collection_owner(&collection, &T::CrossAccountId::from_sub(sender))?;13351336		let mut collection = collection.into_inner();13371338		collection.owner = new_owner;1339		collection.save()1340	}13411342	fn check_collection_owner(1343		collection: &NonfungibleHandle<T>,1344		account: &T::CrossAccountId,1345	) -> DispatchResult {1346		collection1347			.check_is_owner(account)1348			.map_err(Self::map_unique_err_to_proxy)1349	}13501351	pub fn last_collection_idx() -> RmrkCollectionId {1352		<CollectionIndex<T>>::get()1353	}13541355	pub fn unique_collection_id(1356		rmrk_collection_id: RmrkCollectionId,1357	) -> Result<CollectionId, DispatchError> {1358		<UniqueCollectionId<T>>::try_get(rmrk_collection_id)1359			.map_err(|_| <Error<T>>::CollectionUnknown.into())1360	}13611362	pub fn rmrk_collection_id(1363		unique_collection_id: CollectionId,1364	) -> Result<RmrkCollectionId, DispatchError> {1365		Self::get_collection_property_decoded(unique_collection_id, RmrkInternalCollectionId)1366	}13671368	pub fn get_nft_collection(1369		collection_id: CollectionId,1370	) -> Result<NonfungibleHandle<T>, DispatchError> {1371		let collection = <CollectionHandle<T>>::try_get(collection_id)1372			.map_err(|_| <Error<T>>::CollectionUnknown)?;13731374		match collection.mode {1375			CollectionMode::NFT => Ok(NonfungibleHandle::cast(collection)),1376			_ => Err(<Error<T>>::CollectionUnknown.into()),1377		}1378	}13791380	pub fn collection_exists(collection_id: CollectionId) -> bool {1381		<CollectionHandle<T>>::try_get(collection_id).is_ok()1382	}13831384	pub fn get_collection_property(1385		collection_id: CollectionId,1386		key: RmrkProperty,1387	) -> Result<PropertyValue, DispatchError> {1388		let collection_property = <PalletCommon<T>>::collection_properties(collection_id)1389			.get(&Self::rmrk_property_key(key)?)1390			.ok_or(<Error<T>>::CollectionUnknown)?1391			.clone();13921393		Ok(collection_property)1394	}13951396	pub fn get_collection_property_decoded<V: Decode>(1397		collection_id: CollectionId,1398		key: RmrkProperty,1399	) -> Result<V, DispatchError> {1400		Self::decode_property(Self::get_collection_property(collection_id, key)?)1401	}14021403	pub fn get_collection_type(1404		collection_id: CollectionId,1405	) -> Result<misc::CollectionType, DispatchError> {1406		Self::get_collection_property_decoded(collection_id, CollectionType)1407			.map_err(|_| <Error<T>>::CorruptedCollectionType.into())1408	}14091410	pub fn ensure_collection_type(1411		collection_id: CollectionId,1412		collection_type: misc::CollectionType,1413	) -> DispatchResult {1414		let actual_type = Self::get_collection_type(collection_id)?;1415		ensure!(1416			actual_type == collection_type,1417			<CommonError<T>>::NoPermission1418		);14191420		Ok(())1421	}14221423	pub fn get_typed_nft_collection(1424		collection_id: CollectionId,1425		collection_type: misc::CollectionType,1426	) -> Result<NonfungibleHandle<T>, DispatchError> {1427		Self::ensure_collection_type(collection_id, collection_type)?;14281429		Self::get_nft_collection(collection_id)1430	}14311432	pub fn get_typed_nft_collection_mapped(1433		rmrk_collection_id: RmrkCollectionId,1434		collection_type: misc::CollectionType,1435	) -> Result<(NonfungibleHandle<T>, CollectionId), DispatchError> {1436		let unique_collection_id = match collection_type {1437			misc::CollectionType::Regular => Self::unique_collection_id(rmrk_collection_id)?,1438			_ => rmrk_collection_id.into(),1439		};14401441		let collection = Self::get_typed_nft_collection(unique_collection_id, collection_type)?;14421443		Ok((collection, unique_collection_id))1444	}14451446	pub fn get_nft_property(1447		collection_id: CollectionId,1448		nft_id: TokenId,1449		key: RmrkProperty,1450	) -> Result<PropertyValue, DispatchError> {1451		let nft_property = <PalletNft<T>>::token_properties((collection_id, nft_id))1452			.get(&Self::rmrk_property_key(key)?)1453			.ok_or(<Error<T>>::NoAvailableNftId)? // todo replace with better error?1454			.clone();14551456		Ok(nft_property)1457	}14581459	pub fn get_nft_property_decoded<V: Decode>(1460		collection_id: CollectionId,1461		nft_id: TokenId,1462		key: RmrkProperty,1463	) -> Result<V, DispatchError> {1464		Self::decode_property(Self::get_nft_property(collection_id, nft_id, key)?)1465	}14661467	pub fn nft_exists(collection_id: CollectionId, nft_id: TokenId) -> bool {1468		<TokenData<T>>::contains_key((collection_id, nft_id))1469	}14701471	pub fn get_nft_type(1472		collection_id: CollectionId,1473		token_id: TokenId,1474	) -> Result<NftType, DispatchError> {1475		Self::get_nft_property_decoded(collection_id, token_id, TokenType)1476			.map_err(|_| <Error<T>>::NoAvailableNftId.into())1477	}14781479	pub fn ensure_nft_type(1480		collection_id: CollectionId,1481		token_id: TokenId,1482		nft_type: NftType,1483	) -> DispatchResult {1484		let actual_type = Self::get_nft_type(collection_id, token_id)?;1485		ensure!(actual_type == nft_type, <Error<T>>::NoPermission);14861487		Ok(())1488	}14891490	pub fn ensure_nft_owner(1491		collection_id: CollectionId,1492		token_id: TokenId,1493		possible_owner: &T::CrossAccountId,1494		nesting_budget: &dyn budget::Budget,1495	) -> DispatchResult {1496		let is_owned = <PalletStructure<T>>::check_indirectly_owned(1497			possible_owner.clone(),1498			collection_id,1499			token_id,1500			None,1501			nesting_budget,1502		)1503		.map_err(Self::map_unique_err_to_proxy)?;15041505		ensure!(is_owned, <Error<T>>::NoPermission);15061507		Ok(())1508	}15091510	pub fn filter_user_properties<Key, Value, R, Mapper>(1511		collection_id: CollectionId,1512		token_id: Option<TokenId>,1513		filter_keys: Option<Vec<RmrkPropertyKey>>,1514		mapper: Mapper,1515	) -> Result<Vec<R>, DispatchError>1516	where1517		Key: TryFrom<RmrkPropertyKey> + AsRef<[u8]>,1518		Value: Decode + Default,1519		Mapper: Fn(Key, Value) -> R,1520	{1521		filter_keys1522			.map(|keys| {1523				let properties = keys1524					.into_iter()1525					.filter_map(|key| {1526						let key: Key = key.try_into().ok()?;15271528						let value = match token_id {1529							Some(token_id) => Self::get_nft_property_decoded(1530								collection_id,1531								token_id,1532								UserProperty(key.as_ref()),1533							),1534							None => Self::get_collection_property_decoded(1535								collection_id,1536								UserProperty(key.as_ref()),1537							),1538						}1539						.ok()?;15401541						Some(mapper(key, value))1542					})1543					.collect();15441545				Ok(properties)1546			})1547			.unwrap_or_else(|| {1548				let properties =1549					Self::iterate_user_properties(collection_id, token_id, mapper)?.collect();15501551				Ok(properties)1552			})1553	}15541555	pub fn iterate_user_properties<Key, Value, R, Mapper>(1556		collection_id: CollectionId,1557		token_id: Option<TokenId>,1558		mapper: Mapper,1559	) -> Result<impl Iterator<Item = R>, DispatchError>1560	where1561		Key: TryFrom<RmrkPropertyKey> + AsRef<[u8]>,1562		Value: Decode + Default,1563		Mapper: Fn(Key, Value) -> R,1564	{1565		let key_prefix = Self::rmrk_property_key(UserProperty(b""))?;15661567		let properties = match token_id {1568			Some(token_id) => <PalletNft<T>>::token_properties((collection_id, token_id)),1569			None => <PalletCommon<T>>::collection_properties(collection_id),1570		};15711572		let properties = properties.into_iter().filter_map(move |(key, value)| {1573			let key = key.as_slice().strip_prefix(key_prefix.as_slice())?;15741575			let key: Key = key.to_vec().try_into().ok()?;1576			let value: Value = value.decode().ok()?;15771578			Some(mapper(key, value))1579		});15801581		Ok(properties)1582	}15831584	fn map_unique_err_to_proxy(err: DispatchError) -> DispatchError {1585		map_unique_err_to_proxy! {1586			match err {1587				CommonError::NoPermission => NoPermission,1588				CommonError::CollectionTokenLimitExceeded => CollectionFullOrLocked,1589				CommonError::PublicMintingNotAllowed => NoPermission,1590				CommonError::TokenNotFound => NoAvailableNftId,1591				CommonError::ApprovedValueTooLow => NoPermission,1592				CommonError::CantDestroyNotEmptyCollection => CollectionNotEmpty,1593				StructureError::TokenNotFound => NoAvailableNftId,1594				StructureError::OuroborosDetected => CannotSendToDescendentOrSelf,1595			}1596		}1597	}1598}