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

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/>.1617use core::marker::PhantomData;1819use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight};20use up_data_structs::{21	TokenId, CreateItemExData, CollectionId, budget::Budget, Property, PropertyKey,22	PropertyKeyPermission, PropertyValue,23};24use pallet_common::{25	CommonCollectionOperations, CommonWeightInfo, RefungibleExtensions, with_weight,26	weights::WeightInfo as _,27};28use sp_runtime::DispatchError;29use sp_std::{vec::Vec, vec};3031use crate::{32	AccountBalance, Allowance, Config, CreateItemData, Error, NonfungibleHandle, Owned, Pallet,33	SelfWeightOf, TokenData, weights::WeightInfo, TokensMinted,34};3536pub struct CommonWeights<T: Config>(PhantomData<T>);37impl<T: Config> CommonWeightInfo<T::CrossAccountId> for CommonWeights<T> {38	fn create_item() -> Weight {39		<SelfWeightOf<T>>::create_item()40	}4142	fn create_multiple_items_ex(data: &CreateItemExData<T::CrossAccountId>) -> Weight {43		match data {44			CreateItemExData::NFT(t) => {45				<SelfWeightOf<T>>::create_multiple_items_ex(t.len() as u32)46					+ t.iter()47						.filter_map(|t| {48							if t.properties.len() > 0 {49								Some(Self::set_token_properties(t.properties.len() as u32))50							} else {51								None52							}53						})54						.fold(Weight::zero(), |a, b| a.saturating_add(b))55			}56			_ => Weight::zero(),57		}58	}5960	fn create_multiple_items(data: &[up_data_structs::CreateItemData]) -> Weight {61		<SelfWeightOf<T>>::create_multiple_items(data.len() as u32)62			+ data63				.iter()64				.filter_map(|t| match t {65					up_data_structs::CreateItemData::NFT(n) if n.properties.len() > 0 => {66						Some(Self::set_token_properties(n.properties.len() as u32))67					}68					_ => None,69				})70				.fold(Weight::zero(), |a, b| a.saturating_add(b))71	}7273	fn burn_item() -> Weight {74		<SelfWeightOf<T>>::burn_item()75	}7677	fn set_collection_properties(amount: u32) -> Weight {78		<pallet_common::SelfWeightOf<T>>::set_collection_properties(amount)79	}8081	fn delete_collection_properties(amount: u32) -> Weight {82		<pallet_common::SelfWeightOf<T>>::delete_collection_properties(amount)83	}8485	fn set_token_properties(amount: u32) -> Weight {86		<SelfWeightOf<T>>::set_token_properties(amount)87	}8889	fn delete_token_properties(amount: u32) -> Weight {90		<SelfWeightOf<T>>::delete_token_properties(amount)91	}9293	fn set_token_property_permissions(amount: u32) -> Weight {94		<SelfWeightOf<T>>::set_token_property_permissions(amount)95	}9697	fn transfer() -> Weight {98		<SelfWeightOf<T>>::transfer()99	}100101	fn approve() -> Weight {102		<SelfWeightOf<T>>::approve()103	}104105	fn transfer_from() -> Weight {106		<SelfWeightOf<T>>::transfer_from()107	}108109	fn burn_from() -> Weight {110		<SelfWeightOf<T>>::burn_from()111	}112113	fn burn_recursively_self_raw() -> Weight {114		<SelfWeightOf<T>>::burn_recursively_self_raw()115	}116117	fn burn_recursively_breadth_raw(amount: u32) -> Weight {118		<SelfWeightOf<T>>::burn_recursively_breadth_plus_self_plus_self_per_each_raw(amount)119			.saturating_sub(Self::burn_recursively_self_raw().saturating_mul(amount as u64 + 1))120	}121122	fn token_owner() -> Weight {123		<SelfWeightOf<T>>::token_owner()124	}125126	fn set_approval_for_all() -> Weight {127		<SelfWeightOf<T>>::set_approval_for_all()128	}129}130131fn map_create_data<T: Config>(132	data: up_data_structs::CreateItemData,133	to: &T::CrossAccountId,134) -> Result<CreateItemData<T>, DispatchError> {135	match data {136		up_data_structs::CreateItemData::NFT(data) => Ok(CreateItemData::<T> {137			properties: data.properties,138			owner: to.clone(),139		}),140		_ => fail!(<Error<T>>::NotNonfungibleDataUsedToMintFungibleCollectionToken),141	}142}143144/// Implementation of `CommonCollectionOperations` for `NonfungibleHandle`. It wraps Nonfungible Pallete145/// methods and adds weight info.146impl<T: Config> CommonCollectionOperations<T> for NonfungibleHandle<T> {147	fn create_item(148		&self,149		sender: T::CrossAccountId,150		to: T::CrossAccountId,151		data: up_data_structs::CreateItemData,152		nesting_budget: &dyn Budget,153	) -> DispatchResultWithPostInfo {154		with_weight(155			<Pallet<T>>::create_item(156				self,157				&sender,158				map_create_data::<T>(data, &to)?,159				nesting_budget,160			),161			<CommonWeights<T>>::create_item(),162		)163	}164165	fn create_multiple_items(166		&self,167		sender: T::CrossAccountId,168		to: T::CrossAccountId,169		data: Vec<up_data_structs::CreateItemData>,170		nesting_budget: &dyn Budget,171	) -> DispatchResultWithPostInfo {172		let weight = <CommonWeights<T>>::create_multiple_items(&data);173		let data = data174			.into_iter()175			.map(|d| map_create_data::<T>(d, &to))176			.collect::<Result<Vec<_>, DispatchError>>()?;177178		with_weight(179			<Pallet<T>>::create_multiple_items(self, &sender, data, nesting_budget),180			weight,181		)182	}183184	fn create_multiple_items_ex(185		&self,186		sender: <T>::CrossAccountId,187		data: up_data_structs::CreateItemExData<<T>::CrossAccountId>,188		nesting_budget: &dyn Budget,189	) -> DispatchResultWithPostInfo {190		let weight = <CommonWeights<T>>::create_multiple_items_ex(&data);191		let data = match data {192			up_data_structs::CreateItemExData::NFT(nft) => nft,193			_ => fail!(Error::<T>::NotNonfungibleDataUsedToMintFungibleCollectionToken),194		};195196		with_weight(197			<Pallet<T>>::create_multiple_items(self, &sender, data.into_inner(), nesting_budget),198			weight,199		)200	}201202	fn set_collection_properties(203		&self,204		sender: T::CrossAccountId,205		properties: Vec<Property>,206	) -> DispatchResultWithPostInfo {207		let weight = <CommonWeights<T>>::set_collection_properties(properties.len() as u32);208209		with_weight(210			<Pallet<T>>::set_collection_properties(self, &sender, properties),211			weight,212		)213	}214215	fn delete_collection_properties(216		&self,217		sender: &T::CrossAccountId,218		property_keys: Vec<PropertyKey>,219	) -> DispatchResultWithPostInfo {220		let weight = <CommonWeights<T>>::delete_collection_properties(property_keys.len() as u32);221222		with_weight(223			<Pallet<T>>::delete_collection_properties(self, sender, property_keys),224			weight,225		)226	}227228	fn set_token_properties(229		&self,230		sender: T::CrossAccountId,231		token_id: TokenId,232		properties: Vec<Property>,233		nesting_budget: &dyn Budget,234	) -> DispatchResultWithPostInfo {235		let weight = <CommonWeights<T>>::set_token_properties(properties.len() as u32);236237		with_weight(238			<Pallet<T>>::set_token_properties(239				self,240				&sender,241				token_id,242				properties.into_iter(),243				false,244				nesting_budget,245			),246			weight,247		)248	}249250	fn delete_token_properties(251		&self,252		sender: T::CrossAccountId,253		token_id: TokenId,254		property_keys: Vec<PropertyKey>,255		nesting_budget: &dyn Budget,256	) -> DispatchResultWithPostInfo {257		let weight = <CommonWeights<T>>::delete_token_properties(property_keys.len() as u32);258259		with_weight(260			<Pallet<T>>::delete_token_properties(261				self,262				&sender,263				token_id,264				property_keys.into_iter(),265				nesting_budget,266			),267			weight,268		)269	}270271	fn set_token_property_permissions(272		&self,273		sender: &T::CrossAccountId,274		property_permissions: Vec<PropertyKeyPermission>,275	) -> DispatchResultWithPostInfo {276		let weight =277			<CommonWeights<T>>::set_token_property_permissions(property_permissions.len() as u32);278279		with_weight(280			<Pallet<T>>::set_token_property_permissions(self, sender, property_permissions),281			weight,282		)283	}284285	fn burn_item(286		&self,287		sender: T::CrossAccountId,288		token: TokenId,289		amount: u128,290	) -> DispatchResultWithPostInfo {291		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);292		if amount == 1 {293			with_weight(294				<Pallet<T>>::burn(self, &sender, token),295				<CommonWeights<T>>::burn_item(),296			)297		} else {298			<Pallet<T>>::check_token_immediate_ownership(self, token, &sender)?;299			Ok(().into())300		}301	}302303	fn burn_item_recursively(304		&self,305		sender: T::CrossAccountId,306		token: TokenId,307		self_budget: &dyn Budget,308		breadth_budget: &dyn Budget,309	) -> DispatchResultWithPostInfo {310		<Pallet<T>>::burn_recursively(self, &sender, token, self_budget, breadth_budget)311	}312313	fn transfer(314		&self,315		from: T::CrossAccountId,316		to: T::CrossAccountId,317		token: TokenId,318		amount: u128,319		nesting_budget: &dyn Budget,320	) -> DispatchResultWithPostInfo {321		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);322		if amount == 1 {323			with_weight(324				<Pallet<T>>::transfer(self, &from, &to, token, nesting_budget),325				<CommonWeights<T>>::transfer(),326			)327		} else {328			<Pallet<T>>::check_token_immediate_ownership(self, token, &from)?;329			Ok(().into())330		}331	}332333	fn approve(334		&self,335		sender: T::CrossAccountId,336		spender: T::CrossAccountId,337		token: TokenId,338		amount: u128,339	) -> DispatchResultWithPostInfo {340		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);341342		with_weight(343			if amount == 1 {344				<Pallet<T>>::set_allowance(self, &sender, token, Some(&spender))345			} else {346				<Pallet<T>>::set_allowance(self, &sender, token, None)347			},348			<CommonWeights<T>>::approve(),349		)350	}351352	fn transfer_from(353		&self,354		sender: T::CrossAccountId,355		from: T::CrossAccountId,356		to: T::CrossAccountId,357		token: TokenId,358		amount: u128,359		nesting_budget: &dyn Budget,360	) -> DispatchResultWithPostInfo {361		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);362363		if amount == 1 {364			with_weight(365				<Pallet<T>>::transfer_from(self, &sender, &from, &to, token, nesting_budget),366				<CommonWeights<T>>::transfer_from(),367			)368		} else {369			<Pallet<T>>::check_allowed(self, &sender, &from, token, nesting_budget)?;370371			Ok(().into())372		}373	}374375	fn burn_from(376		&self,377		sender: T::CrossAccountId,378		from: T::CrossAccountId,379		token: TokenId,380		amount: u128,381		nesting_budget: &dyn Budget,382	) -> DispatchResultWithPostInfo {383		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);384385		if amount == 1 {386			with_weight(387				<Pallet<T>>::burn_from(self, &sender, &from, token, nesting_budget),388				<CommonWeights<T>>::burn_from(),389			)390		} else {391			<Pallet<T>>::check_allowed(self, &sender, &from, token, nesting_budget)?;392393			Ok(().into())394		}395	}396397	fn check_nesting(398		&self,399		sender: T::CrossAccountId,400		from: (CollectionId, TokenId),401		under: TokenId,402		nesting_budget: &dyn Budget,403	) -> sp_runtime::DispatchResult {404		<Pallet<T>>::check_nesting(self, sender, from, under, nesting_budget)405	}406407	fn nest(&self, under: TokenId, to_nest: (CollectionId, TokenId)) {408		<Pallet<T>>::nest((self.id, under), to_nest);409	}410411	fn unnest(&self, under: TokenId, to_unnest: (CollectionId, TokenId)) {412		<Pallet<T>>::unnest((self.id, under), to_unnest);413	}414415	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId> {416		<Owned<T>>::iter_prefix((self.id, account))417			.map(|(id, _)| id)418			.collect()419	}420421	fn collection_tokens(&self) -> Vec<TokenId> {422		<TokenData<T>>::iter_prefix((self.id,))423			.map(|(id, _)| id)424			.collect()425	}426427	fn token_exists(&self, token: TokenId) -> bool {428		<Pallet<T>>::token_exists(self, token)429	}430431	fn last_token_id(&self) -> TokenId {432		TokenId(<TokensMinted<T>>::get(self.id))433	}434435	fn token_owner(&self, token: TokenId) -> Option<T::CrossAccountId> {436		<TokenData<T>>::get((self.id, token)).map(|t| t.owner)437	}438439	/// Returns token owners.440	fn token_owners(&self, token: TokenId) -> Vec<T::CrossAccountId> {441		self.token_owner(token).map_or_else(|| vec![], |t| vec![t])442	}443444	fn token_property(&self, token_id: TokenId, key: &PropertyKey) -> Option<PropertyValue> {445		<Pallet<T>>::token_properties((self.id, token_id))446			.get(key)447			.cloned()448	}449450	fn token_properties(&self, token_id: TokenId, keys: Option<Vec<PropertyKey>>) -> Vec<Property> {451		let properties = <Pallet<T>>::token_properties((self.id, token_id));452453		keys.map(|keys| {454			keys.into_iter()455				.filter_map(|key| {456					properties.get(&key).map(|value| Property {457						key,458						value: value.clone(),459					})460				})461				.collect()462		})463		.unwrap_or_else(|| {464			properties465				.into_iter()466				.map(|(key, value)| Property { key, value })467				.collect()468		})469	}470471	fn total_supply(&self) -> u32 {472		<Pallet<T>>::total_supply(self)473	}474475	fn account_balance(&self, account: T::CrossAccountId) -> u32 {476		<AccountBalance<T>>::get((self.id, account))477	}478479	fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128 {480		if <TokenData<T>>::get((self.id, token))481			.map(|a| a.owner == account)482			.unwrap_or(false)483		{484			1485		} else {486			0487		}488	}489490	fn allowance(491		&self,492		sender: T::CrossAccountId,493		spender: T::CrossAccountId,494		token: TokenId,495	) -> u128 {496		if <TokenData<T>>::get((self.id, token))497			.map(|a| a.owner != sender)498			.unwrap_or(true)499		{500			0501		} else if <Allowance<T>>::get((self.id, token)) == Some(spender) {502			1503		} else {504			0505		}506	}507508	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>> {509		None510	}511512	fn total_pieces(&self, token: TokenId) -> Option<u128> {513		if <TokenData<T>>::contains_key((self.id, token)) {514			Some(1)515		} else {516			None517		}518	}519520	fn set_approval_for_all(521		&self,522		owner: T::CrossAccountId,523		operator: T::CrossAccountId,524		approve: bool,525	) -> DispatchResultWithPostInfo {526		with_weight(527			<Pallet<T>>::set_approval_for_all(self, &owner, &operator, approve),528			<CommonWeights<T>>::set_approval_for_all(),529		)530	}531532	fn is_approved_for_all(&self, owner: T::CrossAccountId, operator: T::CrossAccountId) -> bool {533		<Pallet<T>>::is_approved_for_all(self, &owner, &operator)534	}535}