git.delta.rocks / unique-network / refs/commits / 5ec8b824c3ad

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, TokenOwnerError,23};24use pallet_common::{25	CommonCollectionOperations, CommonWeightInfo, RefungibleExtensions, with_weight,26	weights::WeightInfo as _, SelfWeightOf as PalletCommonWeightOf,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_multiple_items_ex(data: &CreateItemExData<T::CrossAccountId>) -> Weight {39		match data {40			CreateItemExData::NFT(t) => {41				<SelfWeightOf<T>>::create_multiple_items_ex(t.len() as u32)42					+ t.iter()43						.filter_map(|t| {44							if t.properties.len() > 0 {45								Some(<SelfWeightOf<T>>::reset_token_properties(46									t.properties.len() as u32,47								))48							} else {49								None50							}51						})52						.fold(Weight::zero(), |a, b| a.saturating_add(b))53			}54			_ => Weight::zero(),55		}56	}5758	fn create_multiple_items(data: &[up_data_structs::CreateItemData]) -> Weight {59		<SelfWeightOf<T>>::create_multiple_items(data.len() as u32)60			+ data61				.iter()62				.filter_map(|t| match t {63					up_data_structs::CreateItemData::NFT(n) if n.properties.len() > 0 => Some(64						<SelfWeightOf<T>>::reset_token_properties(n.properties.len() as u32),65					),66					_ => None,67				})68				.fold(Weight::zero(), |a, b| a.saturating_add(b))69	}7071	fn burn_item() -> Weight {72		<SelfWeightOf<T>>::burn_item()73	}7475	fn set_collection_properties(amount: u32) -> Weight {76		<pallet_common::SelfWeightOf<T>>::set_collection_properties(amount)77	}7879	fn delete_collection_properties(amount: u32) -> Weight {80		<pallet_common::SelfWeightOf<T>>::delete_collection_properties(amount)81	}8283	fn set_token_properties(amount: u32) -> Weight {84		<SelfWeightOf<T>>::set_token_properties(amount)85	}8687	fn delete_token_properties(amount: u32) -> Weight {88		<SelfWeightOf<T>>::delete_token_properties(amount)89	}9091	fn set_token_property_permissions(amount: u32) -> Weight {92		<SelfWeightOf<T>>::set_token_property_permissions(amount)93	}9495	fn transfer() -> Weight {96		<SelfWeightOf<T>>::transfer_raw() + <PalletCommonWeightOf<T>>::check_accesslist() * 297	}9899	fn approve() -> Weight {100		<SelfWeightOf<T>>::approve()101	}102103	fn approve_from() -> Weight {104		<SelfWeightOf<T>>::approve_from()105	}106107	fn transfer_from() -> Weight {108		Self::transfer() + <SelfWeightOf<T>>::check_allowed_raw()109	}110111	fn burn_from() -> Weight {112		<SelfWeightOf<T>>::burn_from()113	}114115	fn burn_recursively_self_raw() -> Weight {116		<SelfWeightOf<T>>::burn_recursively_self_raw()117	}118119	fn burn_recursively_breadth_raw(amount: u32) -> Weight {120		<SelfWeightOf<T>>::burn_recursively_breadth_plus_self_plus_self_per_each_raw(amount)121			.saturating_sub(Self::burn_recursively_self_raw().saturating_mul(amount as u64 + 1))122	}123124	fn token_owner() -> Weight {125		<SelfWeightOf<T>>::token_owner()126	}127128	fn set_allowance_for_all() -> Weight {129		<SelfWeightOf<T>>::set_allowance_for_all()130	}131132	fn force_repair_item() -> Weight {133		<SelfWeightOf<T>>::repair_item()134	}135}136137fn map_create_data<T: Config>(138	data: up_data_structs::CreateItemData,139	to: &T::CrossAccountId,140) -> Result<CreateItemData<T>, DispatchError> {141	match data {142		up_data_structs::CreateItemData::NFT(data) => Ok(CreateItemData::<T> {143			properties: data.properties,144			owner: to.clone(),145		}),146		_ => fail!(<Error<T>>::NotNonfungibleDataUsedToMintFungibleCollectionToken),147	}148}149150/// Implementation of `CommonCollectionOperations` for `NonfungibleHandle`. It wraps Nonfungible Pallete151/// methods and adds weight info.152impl<T: Config> CommonCollectionOperations<T> for NonfungibleHandle<T> {153	fn create_item(154		&self,155		sender: T::CrossAccountId,156		to: T::CrossAccountId,157		data: up_data_structs::CreateItemData,158		nesting_budget: &dyn Budget,159	) -> DispatchResultWithPostInfo {160		let weight = <CommonWeights<T>>::create_item(&data);161		with_weight(162			<Pallet<T>>::create_item(163				self,164				&sender,165				map_create_data::<T>(data, &to)?,166				nesting_budget,167			),168			weight,169		)170	}171172	fn create_multiple_items(173		&self,174		sender: T::CrossAccountId,175		to: T::CrossAccountId,176		data: Vec<up_data_structs::CreateItemData>,177		nesting_budget: &dyn Budget,178	) -> DispatchResultWithPostInfo {179		let weight = <CommonWeights<T>>::create_multiple_items(&data);180		let data = data181			.into_iter()182			.map(|d| map_create_data::<T>(d, &to))183			.collect::<Result<Vec<_>, DispatchError>>()?;184185		with_weight(186			<Pallet<T>>::create_multiple_items(self, &sender, data, nesting_budget),187			weight,188		)189	}190191	fn create_multiple_items_ex(192		&self,193		sender: <T>::CrossAccountId,194		data: up_data_structs::CreateItemExData<<T>::CrossAccountId>,195		nesting_budget: &dyn Budget,196	) -> DispatchResultWithPostInfo {197		let weight = <CommonWeights<T>>::create_multiple_items_ex(&data);198		let data = match data {199			up_data_structs::CreateItemExData::NFT(nft) => nft,200			_ => fail!(Error::<T>::NotNonfungibleDataUsedToMintFungibleCollectionToken),201		};202203		with_weight(204			<Pallet<T>>::create_multiple_items(self, &sender, data.into_inner(), nesting_budget),205			weight,206		)207	}208209	fn set_collection_properties(210		&self,211		sender: T::CrossAccountId,212		properties: Vec<Property>,213	) -> DispatchResultWithPostInfo {214		let weight = <CommonWeights<T>>::set_collection_properties(properties.len() as u32);215216		with_weight(217			<Pallet<T>>::set_collection_properties(self, &sender, properties),218			weight,219		)220	}221222	fn delete_collection_properties(223		&self,224		sender: &T::CrossAccountId,225		property_keys: Vec<PropertyKey>,226	) -> DispatchResultWithPostInfo {227		let weight = <CommonWeights<T>>::delete_collection_properties(property_keys.len() as u32);228229		with_weight(230			<Pallet<T>>::delete_collection_properties(self, sender, property_keys),231			weight,232		)233	}234235	fn set_token_properties(236		&self,237		sender: T::CrossAccountId,238		token_id: TokenId,239		properties: Vec<Property>,240		nesting_budget: &dyn Budget,241	) -> DispatchResultWithPostInfo {242		let weight = <CommonWeights<T>>::set_token_properties(properties.len() as u32);243244		with_weight(245			<Pallet<T>>::set_token_properties(246				self,247				&sender,248				token_id,249				properties.into_iter(),250				pallet_common::SetPropertyMode::ExistingToken,251				nesting_budget,252			),253			weight,254		)255	}256257	fn delete_token_properties(258		&self,259		sender: T::CrossAccountId,260		token_id: TokenId,261		property_keys: Vec<PropertyKey>,262		nesting_budget: &dyn Budget,263	) -> DispatchResultWithPostInfo {264		let weight = <CommonWeights<T>>::delete_token_properties(property_keys.len() as u32);265266		with_weight(267			<Pallet<T>>::delete_token_properties(268				self,269				&sender,270				token_id,271				property_keys.into_iter(),272				nesting_budget,273			),274			weight,275		)276	}277278	fn set_token_property_permissions(279		&self,280		sender: &T::CrossAccountId,281		property_permissions: Vec<PropertyKeyPermission>,282	) -> DispatchResultWithPostInfo {283		let weight =284			<CommonWeights<T>>::set_token_property_permissions(property_permissions.len() as u32);285286		with_weight(287			<Pallet<T>>::set_token_property_permissions(self, sender, property_permissions),288			weight,289		)290	}291292	fn burn_item(293		&self,294		sender: T::CrossAccountId,295		token: TokenId,296		amount: u128,297	) -> DispatchResultWithPostInfo {298		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);299		if amount == 1 {300			with_weight(301				<Pallet<T>>::burn(self, &sender, token),302				<CommonWeights<T>>::burn_item(),303			)304		} else {305			<Pallet<T>>::check_token_immediate_ownership(self, token, &sender)?;306			Ok(().into())307		}308	}309310	fn burn_item_recursively(311		&self,312		sender: T::CrossAccountId,313		token: TokenId,314		self_budget: &dyn Budget,315		breadth_budget: &dyn Budget,316	) -> DispatchResultWithPostInfo {317		<Pallet<T>>::burn_recursively(self, &sender, token, self_budget, breadth_budget)318	}319320	fn transfer(321		&self,322		from: T::CrossAccountId,323		to: T::CrossAccountId,324		token: TokenId,325		amount: u128,326		nesting_budget: &dyn Budget,327	) -> DispatchResultWithPostInfo {328		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);329		if amount == 1 {330			<Pallet<T>>::transfer(self, &from, &to, token, nesting_budget)331		} else {332			<Pallet<T>>::check_token_immediate_ownership(self, token, &from)?;333			Ok(().into())334		}335	}336337	fn approve(338		&self,339		sender: T::CrossAccountId,340		spender: T::CrossAccountId,341		token: TokenId,342		amount: u128,343	) -> DispatchResultWithPostInfo {344		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);345346		with_weight(347			if amount == 1 {348				<Pallet<T>>::set_allowance(self, &sender, token, Some(&spender))349			} else {350				<Pallet<T>>::set_allowance(self, &sender, token, None)351			},352			<CommonWeights<T>>::approve(),353		)354	}355356	fn approve_from(357		&self,358		sender: T::CrossAccountId,359		from: T::CrossAccountId,360		to: T::CrossAccountId,361		token: TokenId,362		amount: u128,363	) -> DispatchResultWithPostInfo {364		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);365366		with_weight(367			if amount == 1 {368				<Pallet<T>>::set_allowance_from(self, &sender, &from, token, Some(&to))369			} else {370				<Pallet<T>>::set_allowance_from(self, &sender, &from, token, None)371			},372			<CommonWeights<T>>::approve_from(),373		)374	}375376	fn transfer_from(377		&self,378		sender: T::CrossAccountId,379		from: T::CrossAccountId,380		to: T::CrossAccountId,381		token: TokenId,382		amount: u128,383		nesting_budget: &dyn Budget,384	) -> DispatchResultWithPostInfo {385		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);386387		if amount == 1 {388			<Pallet<T>>::transfer_from(self, &sender, &from, &to, token, nesting_budget)389		} else {390			<Pallet<T>>::check_allowed(self, &sender, &from, token, nesting_budget)?;391392			Ok(().into())393		}394	}395396	fn burn_from(397		&self,398		sender: T::CrossAccountId,399		from: T::CrossAccountId,400		token: TokenId,401		amount: u128,402		nesting_budget: &dyn Budget,403	) -> DispatchResultWithPostInfo {404		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);405406		if amount == 1 {407			with_weight(408				<Pallet<T>>::burn_from(self, &sender, &from, token, nesting_budget),409				<CommonWeights<T>>::burn_from(),410			)411		} else {412			<Pallet<T>>::check_allowed(self, &sender, &from, token, nesting_budget)?;413414			Ok(().into())415		}416	}417418	fn check_nesting(419		&self,420		sender: T::CrossAccountId,421		from: (CollectionId, TokenId),422		under: TokenId,423		nesting_budget: &dyn Budget,424	) -> sp_runtime::DispatchResult {425		<Pallet<T>>::check_nesting(self, sender, from, under, nesting_budget)426	}427428	fn nest(&self, under: TokenId, to_nest: (CollectionId, TokenId)) {429		<Pallet<T>>::nest((self.id, under), to_nest);430	}431432	fn unnest(&self, under: TokenId, to_unnest: (CollectionId, TokenId)) {433		<Pallet<T>>::unnest((self.id, under), to_unnest);434	}435436	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId> {437		<Owned<T>>::iter_prefix((self.id, account))438			.map(|(id, _)| id)439			.collect()440	}441442	fn collection_tokens(&self) -> Vec<TokenId> {443		<TokenData<T>>::iter_prefix((self.id,))444			.map(|(id, _)| id)445			.collect()446	}447448	fn token_exists(&self, token: TokenId) -> bool {449		<Pallet<T>>::token_exists(self, token)450	}451452	fn last_token_id(&self) -> TokenId {453		TokenId(<TokensMinted<T>>::get(self.id))454	}455456	fn token_owner(&self, token: TokenId) -> Result<T::CrossAccountId, TokenOwnerError> {457		<TokenData<T>>::get((self.id, token))458			.map(|t| t.owner)459			.ok_or(TokenOwnerError::NotFound)460	}461462	/// Returns token owners.463	fn token_owners(&self, token: TokenId) -> Vec<T::CrossAccountId> {464		self.token_owner(token).map_or_else(|_| vec![], |t| vec![t])465	}466467	fn token_property(&self, token_id: TokenId, key: &PropertyKey) -> Option<PropertyValue> {468		<Pallet<T>>::token_properties((self.id, token_id))469			.get(key)470			.cloned()471	}472473	fn token_properties(&self, token_id: TokenId, keys: Option<Vec<PropertyKey>>) -> Vec<Property> {474		let properties = <Pallet<T>>::token_properties((self.id, token_id));475476		keys.map(|keys| {477			keys.into_iter()478				.filter_map(|key| {479					properties.get(&key).map(|value| Property {480						key,481						value: value.clone(),482					})483				})484				.collect()485		})486		.unwrap_or_else(|| {487			properties488				.into_iter()489				.map(|(key, value)| Property { key, value })490				.collect()491		})492	}493494	fn total_supply(&self) -> u32 {495		<Pallet<T>>::total_supply(self)496	}497498	fn account_balance(&self, account: T::CrossAccountId) -> u32 {499		<AccountBalance<T>>::get((self.id, account))500	}501502	fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128 {503		if <TokenData<T>>::get((self.id, token))504			.map(|a| a.owner == account)505			.unwrap_or(false)506		{507			1508		} else {509			0510		}511	}512513	fn allowance(514		&self,515		sender: T::CrossAccountId,516		spender: T::CrossAccountId,517		token: TokenId,518	) -> u128 {519		if <TokenData<T>>::get((self.id, token))520			.map(|a| a.owner != sender)521			.unwrap_or(true)522		{523			0524		} else if <Allowance<T>>::get((self.id, token)) == Some(spender) {525			1526		} else {527			0528		}529	}530531	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>> {532		None533	}534535	fn total_pieces(&self, token: TokenId) -> Option<u128> {536		if <TokenData<T>>::contains_key((self.id, token)) {537			Some(1)538		} else {539			None540		}541	}542543	fn set_allowance_for_all(544		&self,545		owner: T::CrossAccountId,546		operator: T::CrossAccountId,547		approve: bool,548	) -> DispatchResultWithPostInfo {549		with_weight(550			<Pallet<T>>::set_allowance_for_all(self, &owner, &operator, approve),551			<CommonWeights<T>>::set_allowance_for_all(),552		)553	}554555	fn allowance_for_all(&self, owner: T::CrossAccountId, operator: T::CrossAccountId) -> bool {556		<Pallet<T>>::allowance_for_all(self, &owner, &operator)557	}558559	fn repair_item(&self, token: TokenId) -> DispatchResultWithPostInfo {560		with_weight(561			<Pallet<T>>::repair_item(self, token),562			<CommonWeights<T>>::force_repair_item(),563		)564	}565}