git.delta.rocks / unique-network / refs/commits / 2999bc8acc0d

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::*;3334pub mod misc;35pub mod property;3637use misc::*;38pub use property::*;3940use RmrkProperty::*;4142const NESTING_BUDGET: u32 = 5;4344#[frame_support::pallet]45pub mod pallet {46	use super::*;47	use pallet_evm::account;4849	#[pallet::config]50	pub trait Config:51		frame_system::Config + pallet_common::Config + pallet_nonfungible::Config + account::Config52	{53		type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;54	}5556	#[pallet::storage]57	#[pallet::getter(fn collection_index)]58	pub type CollectionIndex<T: Config> = StorageValue<_, RmrkCollectionId, ValueQuery>;5960	#[pallet::storage]61	pub type UniqueCollectionId<T: Config> =62		StorageMap<_, Twox64Concat, RmrkCollectionId, CollectionId, ValueQuery>;6364	#[pallet::storage]65	pub type RmrkInernalCollectionId<T: Config> =66		StorageMap<_, Twox64Concat, CollectionId, RmrkCollectionId, ValueQuery>;6768	#[pallet::pallet]69	#[pallet::generate_store(pub(super) trait Store)]70	pub struct Pallet<T>(_);7172	#[pallet::event]73	#[pallet::generate_deposit(pub(super) fn deposit_event)]74	pub enum Event<T: Config> {75		CollectionCreated {76			issuer: T::AccountId,77			collection_id: RmrkCollectionId,78		},79		CollectionDestroyed {80			issuer: T::AccountId,81			collection_id: RmrkCollectionId,82		},83		IssuerChanged {84			old_issuer: T::AccountId,85			new_issuer: T::AccountId,86			collection_id: RmrkCollectionId,87		},88		CollectionLocked {89			issuer: T::AccountId,90			collection_id: RmrkCollectionId,91		},92		NftMinted {93			owner: T::AccountId,94			collection_id: RmrkCollectionId,95			nft_id: RmrkNftId,96		},97		NFTBurned {98			owner: T::AccountId,99			nft_id: RmrkNftId,100		},101		NFTSent {102			sender: T::AccountId,103			recipient: RmrkAccountIdOrCollectionNftTuple<T::AccountId>,104			collection_id: RmrkCollectionId,105			nft_id: RmrkNftId,106			approval_required: bool,107		},108		NFTAccepted {109			sender: T::AccountId,110			recipient: RmrkAccountIdOrCollectionNftTuple<T::AccountId>,111			collection_id: RmrkCollectionId,112			nft_id: RmrkNftId,113		},114		NFTRejected {115			sender: T::AccountId,116			collection_id: RmrkCollectionId,117			nft_id: RmrkNftId,118		},119		PropertySet {120			collection_id: RmrkCollectionId,121			maybe_nft_id: Option<RmrkNftId>,122			key: RmrkKeyString,123			value: RmrkValueString,124		},125		ResourceAdded {126			nft_id: RmrkNftId,127			resource_id: RmrkResourceId,128		},129		ResourceRemoval {130			nft_id: RmrkNftId,131			resource_id: RmrkResourceId,132		},133	}134135	#[pallet::error]136	pub enum Error<T> {137		/* Unique-specific events */138		CorruptedCollectionType,139		NftTypeEncodeError,140		RmrkPropertyKeyIsTooLong,141		RmrkPropertyValueIsTooLong,142143		/* RMRK compatible events */144		CollectionNotEmpty,145		NoAvailableCollectionId,146		NoAvailableNftId,147		CollectionUnknown,148		NoPermission,149		NonTransferable,150		CollectionFullOrLocked,151		ResourceDoesntExist,152		CannotSendToDescendentOrSelf,153		CannotAcceptNonOwnedNft,154		CannotRejectNonOwnedNft,155		ResourceNotPending,156	}157158	#[pallet::call]159	impl<T: Config> Pallet<T> {160		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]161		#[transactional]162		pub fn create_collection(163			origin: OriginFor<T>,164			metadata: RmrkString,165			max: Option<u32>,166			symbol: RmrkCollectionSymbol,167		) -> DispatchResult {168			let sender = ensure_signed(origin)?;169170			let limits = CollectionLimits {171				owner_can_transfer: Some(false),172				token_limit: max,173				..Default::default()174			};175176			let data = CreateCollectionData {177				limits: Some(limits),178				token_prefix: symbol179					.into_inner()180					.try_into()181					.map_err(|_| <CommonError<T>>::CollectionTokenPrefixLimitExceeded)?,182				permissions: Some(CollectionPermissions {183					nesting: Some(NestingRule::Owner),184					..Default::default()185				}),186				..Default::default()187			};188189			let unique_collection_id = Self::init_collection(190				T::CrossAccountId::from_sub(sender.clone()),191				data,192				[193					Self::rmrk_property(Metadata, &metadata)?,194					Self::rmrk_property(CollectionType, &misc::CollectionType::Regular)?,195				]196				.into_iter(),197			)?;198			let rmrk_collection_id = <CollectionIndex<T>>::get();199200			<UniqueCollectionId<T>>::insert(rmrk_collection_id, unique_collection_id);201			<RmrkInernalCollectionId<T>>::insert(unique_collection_id, rmrk_collection_id);202203			<CollectionIndex<T>>::mutate(|n| *n += 1);204205			Self::deposit_event(Event::CollectionCreated {206				issuer: sender,207				collection_id: rmrk_collection_id,208			});209210			Ok(())211		}212213		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]214		#[transactional]215		pub fn destroy_collection(216			origin: OriginFor<T>,217			collection_id: RmrkCollectionId,218		) -> DispatchResult {219			let sender = ensure_signed(origin)?;220			let cross_sender = T::CrossAccountId::from_sub(sender.clone());221222			let collection = Self::get_typed_nft_collection(223				Self::unique_collection_id(collection_id)?,224				misc::CollectionType::Regular,225			)?;226227			<PalletNft<T>>::destroy_collection(collection, &cross_sender)228				.map_err(Self::map_unique_err_to_proxy)?;229230			Self::deposit_event(Event::CollectionDestroyed {231				issuer: sender,232				collection_id,233			});234235			Ok(())236		}237238		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]239		#[transactional]240		pub fn change_collection_issuer(241			origin: OriginFor<T>,242			collection_id: RmrkCollectionId,243			new_issuer: <T::Lookup as StaticLookup>::Source,244		) -> DispatchResult {245			let sender = ensure_signed(origin)?;246247			let new_issuer = T::Lookup::lookup(new_issuer)?;248249			Self::change_collection_owner(250				Self::unique_collection_id(collection_id)?,251				misc::CollectionType::Regular,252				sender.clone(),253				new_issuer.clone(),254			)?;255256			Self::deposit_event(Event::IssuerChanged {257				old_issuer: sender,258				new_issuer,259				collection_id,260			});261262			Ok(())263		}264265		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]266		#[transactional]267		pub fn lock_collection(268			origin: OriginFor<T>,269			collection_id: RmrkCollectionId,270		) -> DispatchResult {271			let sender = ensure_signed(origin)?;272			let cross_sender = T::CrossAccountId::from_sub(sender.clone());273274			let collection = Self::get_typed_nft_collection(275				Self::unique_collection_id(collection_id)?,276				misc::CollectionType::Regular,277			)?;278279			Self::check_collection_owner(&collection, &cross_sender)?;280281			let token_count = collection.total_supply();282283			let mut collection = collection.into_inner();284			collection.limits.token_limit = Some(token_count);285			collection.save()?;286287			Self::deposit_event(Event::CollectionLocked {288				issuer: sender,289				collection_id,290			});291292			Ok(())293		}294295		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]296		#[transactional]297		pub fn mint_nft(298			origin: OriginFor<T>,299			owner: T::AccountId,300			collection_id: RmrkCollectionId,301			recipient: Option<T::AccountId>,302			royalty_amount: Option<Permill>,303			metadata: RmrkString,304			transferable: bool,305		) -> DispatchResult {306			let sender = ensure_signed(origin)?;307			let sender = T::CrossAccountId::from_sub(sender);308			let cross_owner = T::CrossAccountId::from_sub(owner.clone());309310			let royalty_info = royalty_amount.map(|amount| rmrk_traits::RoyaltyInfo {311				recipient: recipient.unwrap_or_else(|| owner.clone()),312				amount,313			});314315			let collection = Self::get_typed_nft_collection(316				Self::unique_collection_id(collection_id)?,317				misc::CollectionType::Regular,318			)?;319320			let nft_id = Self::create_nft(321				&sender,322				&cross_owner,323				&collection,324				[325					Self::rmrk_property(TokenType, &NftType::Regular)?,326					Self::rmrk_property(Transferable, &transferable)?,327					Self::rmrk_property(PendingNftAccept, &false)?,328					Self::rmrk_property(RoyaltyInfo, &royalty_info)?,329					Self::rmrk_property(Metadata, &metadata)?,330					Self::rmrk_property(Equipped, &false)?,331					Self::rmrk_property(332						ResourceCollection,333						&Self::init_collection(334							sender.clone(),335							CreateCollectionData {336								..Default::default()337							},338							[Self::rmrk_property(339								CollectionType,340								&misc::CollectionType::Resource,341							)?]342							.into_iter(),343						)?,344					)?, // todo possibly add limits to the collection if rmrk warrants them345					Self::rmrk_property(ResourcePriorities, &<Vec<u8>>::new())?,346				]347				.into_iter(),348			)349			.map_err(|err| match err {350				DispatchError::Arithmetic(_) => <Error<T>>::NoAvailableNftId.into(),351				err => Self::map_unique_err_to_proxy(err),352			})?;353354			Self::deposit_event(Event::NftMinted {355				owner,356				collection_id,357				nft_id: nft_id.0,358			});359360			Ok(())361		}362363		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]364		#[transactional]365		pub fn burn_nft(366			origin: OriginFor<T>,367			collection_id: RmrkCollectionId,368			nft_id: RmrkNftId,369		) -> DispatchResult {370			let sender = ensure_signed(origin)?;371			let cross_sender = T::CrossAccountId::from_sub(sender.clone());372373			Self::destroy_nft(374				cross_sender,375				Self::unique_collection_id(collection_id)?,376				nft_id.into(),377			)378			.map_err(Self::map_unique_err_to_proxy)?;379380			Self::deposit_event(Event::NFTBurned {381				owner: sender,382				nft_id,383			});384385			Ok(())386		}387388		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]389		#[transactional]390		pub fn send(391			origin: OriginFor<T>,392			rmrk_collection_id: RmrkCollectionId,393			rmrk_nft_id: RmrkNftId,394			new_owner: RmrkAccountIdOrCollectionNftTuple<T::AccountId>,395		) -> DispatchResult {396			let sender = ensure_signed(origin.clone())?;397			let cross_sender = T::CrossAccountId::from_sub(sender.clone());398399			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;400			let nft_id = rmrk_nft_id.into();401402			let token_data =403				<TokenData<T>>::get((collection_id, nft_id)).ok_or(<Error<T>>::NoAvailableNftId)?;404405			let from = token_data.owner;406407			let collection =408				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;409410			ensure!(411				Self::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Transferable)?,412				<Error<T>>::NonTransferable413			);414415			ensure!(416				!Self::get_nft_property_decoded(417					collection_id,418					nft_id,419					RmrkProperty::PendingNftAccept420				)?,421				<Error<T>>::NoPermission422			);423424			let target_owner;425			let approval_required;426427			match new_owner {428				RmrkAccountIdOrCollectionNftTuple::AccountId(ref account_id) => {429					target_owner = T::CrossAccountId::from_sub(account_id.clone());430					approval_required = false;431				}432				RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(433					target_collection_id,434					target_nft_id,435				) => {436					let target_collection_id = Self::unique_collection_id(target_collection_id)?;437438					let target_nft_budget = budget::Value::new(NESTING_BUDGET);439440					let target_nft_owner = <PalletStructure<T>>::get_checked_indirect_owner(441						target_collection_id,442						target_nft_id.into(),443						Some((collection_id, nft_id)),444						&target_nft_budget,445					)446					.map_err(Self::map_unique_err_to_proxy)?;447448					approval_required = cross_sender != target_nft_owner;449450					if approval_required {451						target_owner = target_nft_owner;452453						<PalletNft<T>>::set_scoped_token_property(454							collection.id,455							nft_id,456							PropertyScope::Rmrk,457							Self::rmrk_property(PendingNftAccept, &approval_required)?,458						)?;459					} else {460						target_owner = T::CrossTokenAddressMapping::token_to_address(461							target_collection_id,462							target_nft_id.into(),463						);464					}465				}466			}467468			let src_nft_budget = budget::Value::new(NESTING_BUDGET);469470			<PalletNft<T>>::transfer_from(471				&collection,472				&cross_sender,473				&from,474				&target_owner,475				nft_id,476				&src_nft_budget,477			)478			.map_err(Self::map_unique_err_to_proxy)?;479480			Self::deposit_event(Event::NFTSent {481				sender,482				recipient: new_owner,483				collection_id: rmrk_collection_id,484				nft_id: rmrk_nft_id,485				approval_required,486			});487488			Ok(())489		}490491		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]492		#[transactional]493		pub fn accept_nft(494			origin: OriginFor<T>,495			rmrk_collection_id: RmrkCollectionId,496			rmrk_nft_id: RmrkNftId,497			new_owner: RmrkAccountIdOrCollectionNftTuple<T::AccountId>,498		) -> DispatchResult {499			let sender = ensure_signed(origin.clone())?;500			let cross_sender = T::CrossAccountId::from_sub(sender.clone());501502			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;503			let nft_id = rmrk_nft_id.into();504505			let collection =506				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;507508			let new_cross_owner = match new_owner {509				RmrkAccountIdOrCollectionNftTuple::AccountId(ref account_id) => {510					T::CrossAccountId::from_sub(account_id.clone())511				}512				RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(513					target_collection_id,514					target_nft_id,515				) => {516					let target_collection_id = Self::unique_collection_id(target_collection_id)?;517518					T::CrossTokenAddressMapping::token_to_address(519						target_collection_id,520						TokenId(target_nft_id),521					)522				}523			};524525			let budget = budget::Value::new(NESTING_BUDGET);526527			<PalletNft<T>>::transfer(&collection, &cross_sender, &new_cross_owner, nft_id, &budget)528				.map_err(|err| {529					if err == <CommonError<T>>::OnlyOwnerAllowedToNest.into() {530						<Error<T>>::CannotAcceptNonOwnedNft.into()531					} else {532						Self::map_unique_err_to_proxy(err)533					}534				})?;535536			<PalletNft<T>>::set_scoped_token_property(537				collection.id,538				nft_id,539				PropertyScope::Rmrk,540				Self::rmrk_property(PendingNftAccept, &false)?,541			)?;542543			Self::deposit_event(Event::NFTAccepted {544				sender,545				recipient: new_owner,546				collection_id: rmrk_collection_id,547				nft_id: rmrk_nft_id,548			});549550			Ok(())551		}552553		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]554		#[transactional]555		pub fn reject_nft(556			origin: OriginFor<T>,557			rmrk_collection_id: RmrkCollectionId,558			rmrk_nft_id: RmrkNftId,559		) -> DispatchResult {560			let sender = ensure_signed(origin)?;561			let cross_sender = T::CrossAccountId::from_sub(sender.clone());562563			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;564			let nft_id = rmrk_nft_id.into();565566			Self::destroy_nft(cross_sender, collection_id, nft_id).map_err(|err| {567				if err == <CommonError<T>>::NoPermission.into()568					|| err == <CommonError<T>>::ApprovedValueTooLow.into()569				{570					<Error<T>>::CannotRejectNonOwnedNft.into()571				} else {572					Self::map_unique_err_to_proxy(err)573				}574			})?;575576			Self::deposit_event(Event::NFTRejected {577				sender,578				collection_id: rmrk_collection_id,579				nft_id: rmrk_nft_id,580			});581582			Ok(())583		}584585		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]586		#[transactional]587		pub fn accept_resource(588			origin: OriginFor<T>,589			rmrk_collection_id: RmrkCollectionId,590			rmrk_nft_id: RmrkNftId,591			rmrk_resource_id: RmrkResourceId,592		) -> DispatchResult {593			let sender = ensure_signed(origin)?;594			let cross_sender = T::CrossAccountId::from_sub(sender);595596			let collection_id = Self::unique_collection_id(rmrk_collection_id)597				.map_err(|_| <Error<T>>::ResourceDoesntExist)?;598599			let nft_id = rmrk_nft_id.into();600			let resource_id = rmrk_resource_id.into();601602			let budget = budget::Value::new(NESTING_BUDGET);603604			let nft_owner =605				<PalletStructure<T>>::find_topmost_owner(collection_id, nft_id, &budget)606					.map_err(|_| <Error<T>>::ResourceDoesntExist)?;607608			let resource_collection_id: CollectionId =609				Self::get_nft_property_decoded(collection_id, nft_id, ResourceCollection)610					.map_err(|_| <Error<T>>::ResourceDoesntExist)?;611612			let is_pending: bool = Self::get_nft_property_decoded(613				resource_collection_id,614				resource_id,615				PendingResourceAccept,616			)617			.map_err(|_| <Error<T>>::ResourceDoesntExist)?;618619			ensure!(is_pending, <Error<T>>::ResourceNotPending);620621			ensure!(cross_sender == nft_owner, <Error<T>>::NoPermission);622623			<PalletNft<T>>::set_scoped_token_property(624				resource_collection_id,625				rmrk_resource_id.into(),626				PropertyScope::Rmrk,627				Self::rmrk_property(PendingResourceAccept, &false)?,628			)?;629630			Ok(())631		}632633		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]634		#[transactional]635		pub fn accept_resource_removal(636			origin: OriginFor<T>,637			rmrk_collection_id: RmrkCollectionId,638			rmrk_nft_id: RmrkNftId,639			rmrk_resource_id: RmrkResourceId,640		) -> DispatchResult {641			let sender = ensure_signed(origin)?;642			let cross_sender = T::CrossAccountId::from_sub(sender);643644			let collection_id = Self::unique_collection_id(rmrk_collection_id)645				.map_err(|_| <Error<T>>::ResourceDoesntExist)?;646647			let nft_id = rmrk_nft_id.into();648			let resource_id = rmrk_resource_id.into();649650			let budget = budget::Value::new(NESTING_BUDGET);651652			let nft_owner =653				<PalletStructure<T>>::find_topmost_owner(collection_id, nft_id, &budget)654					.map_err(|_| <Error<T>>::ResourceDoesntExist)?;655656			ensure!(cross_sender == nft_owner, <Error<T>>::NoPermission);657658			let resource_collection_id: CollectionId =659				Self::get_nft_property_decoded(collection_id, nft_id, ResourceCollection)660					.map_err(|_| <Error<T>>::ResourceDoesntExist)?;661662			let is_pending: bool = Self::get_nft_property_decoded(663				resource_collection_id,664				resource_id,665				PendingResourceRemoval,666			)667			.map_err(|_| <Error<T>>::ResourceDoesntExist)?;668669			ensure!(is_pending, <Error<T>>::ResourceNotPending);670671			let resource_collection = Self::get_typed_nft_collection(672				resource_collection_id,673				misc::CollectionType::Resource,674			)?;675676			<PalletNft<T>>::burn(&resource_collection, &cross_sender, rmrk_resource_id.into())677				.map_err(Self::map_unique_err_to_proxy)?;678679			Ok(())680		}681682		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]683		#[transactional]684		pub fn set_property(685			origin: OriginFor<T>,686			#[pallet::compact] rmrk_collection_id: RmrkCollectionId,687			maybe_nft_id: Option<RmrkNftId>,688			key: RmrkKeyString,689			value: RmrkValueString,690		) -> DispatchResult {691			let sender = ensure_signed(origin)?;692			let sender = T::CrossAccountId::from_sub(sender);693694			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;695			let budget = budget::Value::new(NESTING_BUDGET);696697			match maybe_nft_id {698				Some(nft_id) => {699					let token_id: TokenId = nft_id.into();700701					Self::ensure_nft_type(collection_id, token_id, NftType::Regular)?;702					Self::ensure_nft_owner(collection_id, token_id, &sender, &budget)?;703704					<PalletNft<T>>::set_scoped_token_property(705						collection_id,706						token_id,707						PropertyScope::Rmrk,708						Self::rmrk_property(UserProperty(key.as_slice()), &value)?,709					)?;710				}711				None => {712					let collection = Self::get_typed_nft_collection(713						collection_id,714						misc::CollectionType::Regular,715					)?;716717					Self::check_collection_owner(&collection, &sender)?;718719					<PalletCommon<T>>::set_scoped_collection_property(720						collection_id,721						PropertyScope::Rmrk,722						Self::rmrk_property(UserProperty(key.as_slice()), &value)?,723					)?;724				}725			}726727			Self::deposit_event(Event::PropertySet {728				collection_id: rmrk_collection_id,729				maybe_nft_id,730				key,731				value,732			});733734			Ok(())735		}736737		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]738		#[transactional]739		pub fn set_priority(740			origin: OriginFor<T>,741			rmrk_collection_id: RmrkCollectionId,742			rmrk_nft_id: RmrkNftId,743			priorities: BoundedVec<RmrkResourceId, RmrkMaxPriorities>,744		) -> DispatchResult {745			let sender = ensure_signed(origin)?;746			let sender = T::CrossAccountId::from_sub(sender);747748			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;749			let nft_id = rmrk_nft_id.into();750			let budget = budget::Value::new(NESTING_BUDGET);751752			Self::ensure_nft_type(collection_id, nft_id, NftType::Regular)?;753			Self::ensure_nft_owner(collection_id, nft_id, &sender, &budget)?;754755			<PalletNft<T>>::set_scoped_token_property(756				collection_id,757				nft_id,758				PropertyScope::Rmrk,759				Self::rmrk_property(ResourcePriorities, &priorities.into_inner())?,760			)?;761762			Ok(())763		}764765		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]766		#[transactional]767		pub fn add_basic_resource(768			origin: OriginFor<T>,769			collection_id: RmrkCollectionId,770			nft_id: RmrkNftId,771			resource: RmrkBasicResource,772		) -> DispatchResult {773			let sender = ensure_signed(origin.clone())?;774775			let resource_id = Self::resource_add(776				sender,777				Self::unique_collection_id(collection_id)?,778				nft_id.into(),779				[780					Self::rmrk_property(TokenType, &NftType::Resource)?,781					Self::rmrk_property(ResourceType, &misc::ResourceType::Basic)?,782					Self::rmrk_property(Src, &resource.src)?,783					Self::rmrk_property(Metadata, &resource.metadata)?,784					Self::rmrk_property(License, &resource.license)?,785					Self::rmrk_property(Thumb, &resource.thumb)?,786				]787				.into_iter(),788			)?;789790			Self::deposit_event(Event::ResourceAdded {791				nft_id,792				resource_id,793			});794			Ok(())795		}796797		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]798		#[transactional]799		pub fn add_composable_resource(800			origin: OriginFor<T>,801			collection_id: RmrkCollectionId,802			nft_id: RmrkNftId,803			_resource_id: RmrkBoundedResource,804			resource: RmrkComposableResource,805		) -> DispatchResult {806			let sender = ensure_signed(origin.clone())?;807808			let resource_id = Self::resource_add(809				sender,810				Self::unique_collection_id(collection_id)?,811				nft_id.into(),812				[813					Self::rmrk_property(TokenType, &NftType::Resource)?,814					Self::rmrk_property(ResourceType, &misc::ResourceType::Composable)?,815					Self::rmrk_property(Parts, &resource.parts)?,816					Self::rmrk_property(Base, &resource.base)?,817					Self::rmrk_property(Src, &resource.src)?,818					Self::rmrk_property(Metadata, &resource.metadata)?,819					Self::rmrk_property(License, &resource.license)?,820					Self::rmrk_property(Thumb, &resource.thumb)?,821				]822				.into_iter(),823			)?;824825			Self::deposit_event(Event::ResourceAdded {826				nft_id,827				resource_id,828			});829			Ok(())830		}831832		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]833		#[transactional]834		pub fn add_slot_resource(835			origin: OriginFor<T>,836			collection_id: RmrkCollectionId,837			nft_id: RmrkNftId,838			resource: RmrkSlotResource,839		) -> DispatchResult {840			let sender = ensure_signed(origin.clone())?;841842			let resource_id = Self::resource_add(843				sender,844				Self::unique_collection_id(collection_id)?,845				nft_id.into(),846				[847					Self::rmrk_property(TokenType, &NftType::Resource)?,848					Self::rmrk_property(ResourceType, &misc::ResourceType::Slot)?,849					Self::rmrk_property(Base, &resource.base)?,850					Self::rmrk_property(Src, &resource.src)?,851					Self::rmrk_property(Metadata, &resource.metadata)?,852					Self::rmrk_property(Slot, &resource.slot)?,853					Self::rmrk_property(License, &resource.license)?,854					Self::rmrk_property(Thumb, &resource.thumb)?,855				]856				.into_iter(),857			)?;858859			Self::deposit_event(Event::ResourceAdded {860				nft_id,861				resource_id,862			});863			Ok(())864		}865866		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]867		#[transactional]868		pub fn remove_resource(869			origin: OriginFor<T>,870			collection_id: RmrkCollectionId,871			nft_id: RmrkNftId,872			resource_id: RmrkResourceId,873		) -> DispatchResult {874			let sender = ensure_signed(origin.clone())?;875876			Self::resource_remove(877				sender,878				Self::unique_collection_id(collection_id)?,879				nft_id.into(),880				resource_id.into(),881			)?;882883			Self::deposit_event(Event::ResourceRemoval {884				nft_id,885				resource_id,886			});887			Ok(())888		}889	}890}891892impl<T: Config> Pallet<T> {893	pub fn rmrk_property_key(rmrk_key: RmrkProperty) -> Result<PropertyKey, DispatchError> {894		let key = rmrk_key.to_key::<T>()?;895896		let scoped_key = PropertyScope::Rmrk897			.apply(key)898			.map_err(|_| <Error<T>>::RmrkPropertyKeyIsTooLong)?;899900		Ok(scoped_key)901	}902903	// todo think about renaming these904	pub fn rmrk_property<E: Encode>(905		rmrk_key: RmrkProperty,906		value: &E,907	) -> Result<Property, DispatchError> {908		let key = rmrk_key.to_key::<T>()?;909910		let value = value911			.encode()912			.try_into()913			.map_err(|_| <Error<T>>::RmrkPropertyValueIsTooLong)?;914915		let property = Property { key, value };916917		Ok(property)918	}919920	pub fn decode_property<D: Decode>(vec: PropertyValue) -> Result<D, DispatchError> {921		vec.decode()922			.map_err(|_| <Error<T>>::RmrkPropertyValueIsTooLong.into())923	}924925	pub fn rebind<L, S>(vec: &BoundedVec<u8, L>) -> Result<BoundedVec<u8, S>, DispatchError>926	where927		BoundedVec<u8, S>: TryFrom<Vec<u8>>,928	{929		vec.rebind()930			.map_err(|_| <Error<T>>::RmrkPropertyValueIsTooLong.into())931	}932933	fn init_collection(934		sender: T::CrossAccountId,935		data: CreateCollectionData<T::AccountId>,936		properties: impl Iterator<Item = Property>,937	) -> Result<CollectionId, DispatchError> {938		let collection_id = <PalletNft<T>>::init_collection(sender, data);939940		if let Err(DispatchError::Arithmetic(_)) = &collection_id {941			return Err(<Error<T>>::NoAvailableCollectionId.into());942		}943944		<PalletCommon<T>>::set_scoped_collection_properties(945			collection_id?,946			PropertyScope::Rmrk,947			properties,948		)?;949950		collection_id951	}952953	pub fn create_nft(954		sender: &T::CrossAccountId,955		owner: &T::CrossAccountId,956		collection: &NonfungibleHandle<T>,957		properties: impl Iterator<Item = Property>,958	) -> Result<TokenId, DispatchError> {959		let data = CreateNftExData {960			properties: BoundedVec::default(),961			owner: owner.clone(),962		};963964		let budget = budget::Value::new(NESTING_BUDGET);965966		<PalletNft<T>>::create_item(collection, sender, data, &budget)?;967968		let nft_id = <PalletNft<T>>::current_token_id(collection.id);969970		<PalletNft<T>>::set_scoped_token_properties(971			collection.id,972			nft_id,973			PropertyScope::Rmrk,974			properties,975		)?;976977		Ok(nft_id)978	}979980	fn destroy_nft(981		sender: T::CrossAccountId,982		collection_id: CollectionId,983		token_id: TokenId,984	) -> DispatchResult {985		let collection =986			Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;987988		let token_data =989			<TokenData<T>>::get((collection_id, token_id)).ok_or(<Error<T>>::NoAvailableNftId)?;990991		let from = token_data.owner;992993		let budget = budget::Value::new(NESTING_BUDGET);994995		<PalletNft<T>>::burn_from(&collection, &sender, &from, token_id, &budget)996	}997998	fn resource_add(999		sender: T::AccountId,1000		collection_id: CollectionId,1001		token_id: TokenId,1002		resource_properties: impl Iterator<Item = Property>,1003	) -> Result<RmrkResourceId, DispatchError> {1004		let collection =1005			Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1006		ensure!(collection.owner == sender, Error::<T>::NoPermission);10071008		let sender = T::CrossAccountId::from_sub(sender);1009		let budget = budget::Value::new(NESTING_BUDGET);10101011		let nft_owner = <PalletStructure<T>>::find_topmost_owner(collection_id, token_id, &budget)1012			.map_err(Self::map_unique_err_to_proxy)?;10131014		let pending = sender != nft_owner;10151016		let resource_collection_id: CollectionId =1017			Self::get_nft_property_decoded(collection_id, token_id, ResourceCollection)?;1018		let resource_collection =1019			Self::get_typed_nft_collection(resource_collection_id, misc::CollectionType::Resource)?;10201021		// todo probably add extra connections to bases, slots, etc., when RMRK starts to use them10221023		let resource_id = Self::create_nft(1024			&sender,1025			&nft_owner,1026			&resource_collection,1027			resource_properties.chain(1028				[1029					Self::rmrk_property(PendingResourceAccept, &pending)?,1030					Self::rmrk_property(PendingResourceRemoval, &false)?,1031				]1032				.into_iter(),1033			),1034		)1035		.map_err(|err| match err {1036			DispatchError::Arithmetic(_) => <Error<T>>::NoAvailableNftId.into(),1037			err => Self::map_unique_err_to_proxy(err),1038		})?;10391040		Ok(resource_id.0)1041	}10421043	fn resource_remove(1044		sender: T::AccountId,1045		collection_id: CollectionId,1046		nft_id: TokenId,1047		resource_id: TokenId,1048	) -> DispatchResult {1049		let collection =1050			Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1051		ensure!(collection.owner == sender, Error::<T>::NoPermission);10521053		let resource_collection_id: CollectionId =1054			Self::get_nft_property_decoded(collection_id, nft_id, ResourceCollection)?;1055		let resource_collection =1056			Self::get_typed_nft_collection(resource_collection_id, misc::CollectionType::Resource)?;1057		ensure!(1058			<PalletNft<T>>::token_exists(&resource_collection, resource_id),1059			Error::<T>::ResourceDoesntExist1060		);10611062		let budget = up_data_structs::budget::Value::new(10);1063		let topmost_owner =1064			<PalletStructure<T>>::find_topmost_owner(collection_id, nft_id, &budget)?;10651066		let sender = T::CrossAccountId::from_sub(sender);1067		if topmost_owner == sender {1068			<PalletNft<T>>::burn(&resource_collection, &sender, resource_id)1069				.map_err(Self::map_unique_err_to_proxy)?;1070		} else {1071			<PalletNft<T>>::set_scoped_token_property(1072				resource_collection_id,1073				resource_id,1074				PropertyScope::Rmrk,1075				Self::rmrk_property(PendingResourceRemoval, &true)?,1076			)?;1077		}10781079		Ok(())1080	}10811082	fn change_collection_owner(1083		collection_id: CollectionId,1084		collection_type: misc::CollectionType,1085		sender: T::AccountId,1086		new_owner: T::AccountId,1087	) -> DispatchResult {1088		let collection = Self::get_typed_nft_collection(collection_id, collection_type)?;1089		Self::check_collection_owner(&collection, &T::CrossAccountId::from_sub(sender))?;10901091		let mut collection = collection.into_inner();10921093		collection.owner = new_owner;1094		collection.save()1095	}10961097	fn check_collection_owner(1098		collection: &NonfungibleHandle<T>,1099		account: &T::CrossAccountId,1100	) -> DispatchResult {1101		collection1102			.check_is_owner(account)1103			.map_err(Self::map_unique_err_to_proxy)1104	}11051106	pub fn last_collection_idx() -> RmrkCollectionId {1107		<CollectionIndex<T>>::get()1108	}11091110	pub fn unique_collection_id(1111		rmrk_collection_id: RmrkCollectionId,1112	) -> Result<CollectionId, DispatchError> {1113		<UniqueCollectionId<T>>::try_get(rmrk_collection_id)1114			.map_err(|_| <Error<T>>::CollectionUnknown.into())1115	}11161117	pub fn rmrk_collection_id(1118		unique_collection_id: CollectionId,1119	) -> Result<RmrkCollectionId, DispatchError> {1120		<RmrkInernalCollectionId<T>>::try_get(unique_collection_id)1121			.map_err(|_| <Error<T>>::CollectionUnknown.into())1122	}11231124	pub fn get_nft_collection(1125		collection_id: CollectionId,1126	) -> Result<NonfungibleHandle<T>, DispatchError> {1127		let collection = <CollectionHandle<T>>::try_get(collection_id)1128			.map_err(|_| <Error<T>>::CollectionUnknown)?;11291130		match collection.mode {1131			CollectionMode::NFT => Ok(NonfungibleHandle::cast(collection)),1132			_ => Err(<Error<T>>::CollectionUnknown.into()),1133		}1134	}11351136	pub fn collection_exists(collection_id: CollectionId) -> bool {1137		<CollectionHandle<T>>::try_get(collection_id).is_ok()1138	}11391140	pub fn get_collection_property(1141		collection_id: CollectionId,1142		key: RmrkProperty,1143	) -> Result<PropertyValue, DispatchError> {1144		let collection_property = <PalletCommon<T>>::collection_properties(collection_id)1145			.get(&Self::rmrk_property_key(key)?)1146			.ok_or(<Error<T>>::CollectionUnknown)?1147			.clone();11481149		Ok(collection_property)1150	}11511152	pub fn get_collection_property_decoded<V: Decode>(1153		collection_id: CollectionId,1154		key: RmrkProperty,1155	) -> Result<V, DispatchError> {1156		Self::decode_property(Self::get_collection_property(collection_id, key)?)1157	}11581159	pub fn get_collection_type(1160		collection_id: CollectionId,1161	) -> Result<misc::CollectionType, DispatchError> {1162		Self::get_collection_property_decoded(collection_id, CollectionType)1163			.map_err(|_| <Error<T>>::CorruptedCollectionType.into())1164	}11651166	pub fn ensure_collection_type(1167		collection_id: CollectionId,1168		collection_type: misc::CollectionType,1169	) -> DispatchResult {1170		let actual_type = Self::get_collection_type(collection_id)?;1171		ensure!(1172			actual_type == collection_type,1173			<CommonError<T>>::NoPermission1174		);11751176		Ok(())1177	}11781179	pub fn get_typed_nft_collection(1180		collection_id: CollectionId,1181		collection_type: misc::CollectionType,1182	) -> Result<NonfungibleHandle<T>, DispatchError> {1183		Self::ensure_collection_type(collection_id, collection_type)?;11841185		Self::get_nft_collection(collection_id)1186	}11871188	pub fn get_typed_nft_collection_mapped(1189		rmrk_collection_id: RmrkCollectionId,1190		collection_type: misc::CollectionType,1191	) -> Result<(NonfungibleHandle<T>, CollectionId), DispatchError> {1192		let unique_collection_id = match collection_type {1193			misc::CollectionType::Regular => Self::unique_collection_id(rmrk_collection_id)?,1194			_ => rmrk_collection_id.into(),1195		};11961197		let collection = Self::get_typed_nft_collection(unique_collection_id, collection_type)?;11981199		Ok((collection, unique_collection_id))1200	}12011202	pub fn get_nft_property(1203		collection_id: CollectionId,1204		nft_id: TokenId,1205		key: RmrkProperty,1206	) -> Result<PropertyValue, DispatchError> {1207		let nft_property = <PalletNft<T>>::token_properties((collection_id, nft_id))1208			.get(&Self::rmrk_property_key(key)?)1209			.ok_or(<Error<T>>::NoAvailableNftId)? // todo replace with better error?1210			.clone();12111212		Ok(nft_property)1213	}12141215	pub fn get_nft_property_decoded<V: Decode>(1216		collection_id: CollectionId,1217		nft_id: TokenId,1218		key: RmrkProperty,1219	) -> Result<V, DispatchError> {1220		Self::decode_property(Self::get_nft_property(collection_id, nft_id, key)?)1221	}12221223	pub fn nft_exists(collection_id: CollectionId, nft_id: TokenId) -> bool {1224		<TokenData<T>>::contains_key((collection_id, nft_id))1225	}12261227	pub fn get_nft_type(1228		collection_id: CollectionId,1229		token_id: TokenId,1230	) -> Result<NftType, DispatchError> {1231		Self::get_nft_property_decoded(collection_id, token_id, TokenType)1232			.map_err(|_| <Error<T>>::NoAvailableNftId.into())1233	}12341235	pub fn ensure_nft_type(1236		collection_id: CollectionId,1237		token_id: TokenId,1238		nft_type: NftType,1239	) -> DispatchResult {1240		let actual_type = Self::get_nft_type(collection_id, token_id)?;1241		ensure!(actual_type == nft_type, <Error<T>>::NoPermission);12421243		Ok(())1244	}12451246	pub fn ensure_nft_owner(1247		collection_id: CollectionId,1248		token_id: TokenId,1249		possible_owner: &T::CrossAccountId,1250		nesting_budget: &dyn budget::Budget,1251	) -> DispatchResult {1252		let is_owned = <PalletStructure<T>>::check_indirectly_owned(1253			possible_owner.clone(),1254			collection_id,1255			token_id,1256			None,1257			nesting_budget,1258		)1259		.map_err(Self::map_unique_err_to_proxy)?;12601261		ensure!(is_owned, <Error<T>>::NoPermission);12621263		Ok(())1264	}12651266	pub fn filter_user_properties<Key, Value, R, Mapper>(1267		collection_id: CollectionId,1268		token_id: Option<TokenId>,1269		filter_keys: Option<Vec<RmrkPropertyKey>>,1270		mapper: Mapper,1271	) -> Result<Vec<R>, DispatchError>1272	where1273		Key: TryFrom<RmrkPropertyKey> + AsRef<[u8]>,1274		Value: Decode + Default,1275		Mapper: Fn(Key, Value) -> R,1276	{1277		filter_keys1278			.map(|keys| {1279				let properties = keys1280					.into_iter()1281					.filter_map(|key| {1282						let key: Key = key.try_into().ok()?;12831284						let value = match token_id {1285							Some(token_id) => Self::get_nft_property_decoded(1286								collection_id,1287								token_id,1288								UserProperty(key.as_ref()),1289							),1290							None => Self::get_collection_property_decoded(1291								collection_id,1292								UserProperty(key.as_ref()),1293							),1294						}1295						.ok()?;12961297						Some(mapper(key, value))1298					})1299					.collect();13001301				Ok(properties)1302			})1303			.unwrap_or_else(|| {1304				let properties =1305					Self::iterate_user_properties(collection_id, token_id, mapper)?.collect();13061307				Ok(properties)1308			})1309	}13101311	pub fn iterate_user_properties<Key, Value, R, Mapper>(1312		collection_id: CollectionId,1313		token_id: Option<TokenId>,1314		mapper: Mapper,1315	) -> Result<impl Iterator<Item = R>, DispatchError>1316	where1317		Key: TryFrom<RmrkPropertyKey> + AsRef<[u8]>,1318		Value: Decode + Default,1319		Mapper: Fn(Key, Value) -> R,1320	{1321		let key_prefix = Self::rmrk_property_key(UserProperty(b""))?;13221323		let properties = match token_id {1324			Some(token_id) => <PalletNft<T>>::token_properties((collection_id, token_id)),1325			None => <PalletCommon<T>>::collection_properties(collection_id),1326		};13271328		let properties = properties.into_iter().filter_map(move |(key, value)| {1329			let key = key.as_slice().strip_prefix(key_prefix.as_slice())?;13301331			let key: Key = key.to_vec().try_into().ok()?;1332			let value: Value = value.decode().ok()?;13331334			Some(mapper(key, value))1335		});13361337		Ok(properties)1338	}13391340	fn map_unique_err_to_proxy(err: DispatchError) -> DispatchError {1341		map_unique_err_to_proxy! {1342			match err {1343				CommonError::NoPermission => NoPermission,1344				CommonError::CollectionTokenLimitExceeded => CollectionFullOrLocked,1345				CommonError::PublicMintingNotAllowed => NoPermission,1346				CommonError::TokenNotFound => NoAvailableNftId,1347				CommonError::ApprovedValueTooLow => NoPermission,1348				CommonError::CantDestroyNotEmptyCollection => CollectionNotEmpty,1349				StructureError::TokenNotFound => NoAvailableNftId,1350				StructureError::OuroborosDetected => CannotSendToDescendentOrSelf,1351			}1352		}1353	}1354}