git.delta.rocks / unique-network / refs/commits / 008833a7ebae

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(Self::set_token_properties(t.properties.len() as u32))46							} else {47								None48							}49						})50						.fold(Weight::zero(), |a, b| a.saturating_add(b))51			}52			_ => Weight::zero(),53		}54	}5556	fn create_multiple_items(data: &[up_data_structs::CreateItemData]) -> Weight {57		<SelfWeightOf<T>>::create_multiple_items(data.len() as u32)58			+ data59				.iter()60				.filter_map(|t| match t {61					up_data_structs::CreateItemData::NFT(n) if n.properties.len() > 0 => {62						Some(Self::set_token_properties(n.properties.len() as u32))63					}64					_ => None,65				})66				.fold(Weight::zero(), |a, b| a.saturating_add(b))67	}6869	fn burn_item() -> Weight {70		<SelfWeightOf<T>>::burn_item()71	}7273	fn set_collection_properties(amount: u32) -> Weight {74		<pallet_common::SelfWeightOf<T>>::set_collection_properties(amount)75	}7677	fn delete_collection_properties(amount: u32) -> Weight {78		<pallet_common::SelfWeightOf<T>>::delete_collection_properties(amount)79	}8081	fn set_token_properties(amount: u32) -> Weight {82		<SelfWeightOf<T>>::set_token_properties(amount)83	}8485	fn delete_token_properties(amount: u32) -> Weight {86		<SelfWeightOf<T>>::delete_token_properties(amount)87	}8889	fn set_token_property_permissions(amount: u32) -> Weight {90		<SelfWeightOf<T>>::set_token_property_permissions(amount)91	}9293	fn transfer() -> Weight {94		<SelfWeightOf<T>>::transfer_raw() + <PalletCommonWeightOf<T>>::check_accesslist() * 295	}9697	fn approve() -> Weight {98		<SelfWeightOf<T>>::approve()99	}100101	fn approve_from() -> Weight {102		<SelfWeightOf<T>>::approve_from()103	}104105	fn transfer_from() -> Weight {106		Self::transfer() + <SelfWeightOf<T>>::checks_allowed_raw()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_allowance_for_all() -> Weight {127		<SelfWeightOf<T>>::set_allowance_for_all()128	}129130	fn force_repair_item() -> Weight {131		<SelfWeightOf<T>>::repair_item()132	}133}134135fn map_create_data<T: Config>(136	data: up_data_structs::CreateItemData,137	to: &T::CrossAccountId,138) -> Result<CreateItemData<T>, DispatchError> {139	match data {140		up_data_structs::CreateItemData::NFT(data) => Ok(CreateItemData::<T> {141			properties: data.properties,142			owner: to.clone(),143		}),144		_ => fail!(<Error<T>>::NotNonfungibleDataUsedToMintFungibleCollectionToken),145	}146}147148/// Implementation of `CommonCollectionOperations` for `NonfungibleHandle`. It wraps Nonfungible Pallete149/// methods and adds weight info.150impl<T: Config> CommonCollectionOperations<T> for NonfungibleHandle<T> {151	fn create_item(152		&self,153		sender: T::CrossAccountId,154		to: T::CrossAccountId,155		data: up_data_structs::CreateItemData,156		nesting_budget: &dyn Budget,157	) -> DispatchResultWithPostInfo {158		let weight = <CommonWeights<T>>::create_item(&data);159		with_weight(160			<Pallet<T>>::create_item(161				self,162				&sender,163				map_create_data::<T>(data, &to)?,164				nesting_budget,165			),166			weight,167		)168	}169170	fn create_multiple_items(171		&self,172		sender: T::CrossAccountId,173		to: T::CrossAccountId,174		data: Vec<up_data_structs::CreateItemData>,175		nesting_budget: &dyn Budget,176	) -> DispatchResultWithPostInfo {177		let weight = <CommonWeights<T>>::create_multiple_items(&data);178		let data = data179			.into_iter()180			.map(|d| map_create_data::<T>(d, &to))181			.collect::<Result<Vec<_>, DispatchError>>()?;182183		with_weight(184			<Pallet<T>>::create_multiple_items(self, &sender, data, nesting_budget),185			weight,186		)187	}188189	fn create_multiple_items_ex(190		&self,191		sender: <T>::CrossAccountId,192		data: up_data_structs::CreateItemExData<<T>::CrossAccountId>,193		nesting_budget: &dyn Budget,194	) -> DispatchResultWithPostInfo {195		let weight = <CommonWeights<T>>::create_multiple_items_ex(&data);196		let data = match data {197			up_data_structs::CreateItemExData::NFT(nft) => nft,198			_ => fail!(Error::<T>::NotNonfungibleDataUsedToMintFungibleCollectionToken),199		};200201		with_weight(202			<Pallet<T>>::create_multiple_items(self, &sender, data.into_inner(), nesting_budget),203			weight,204		)205	}206207	fn set_collection_properties(208		&self,209		sender: T::CrossAccountId,210		properties: Vec<Property>,211	) -> DispatchResultWithPostInfo {212		let weight = <CommonWeights<T>>::set_collection_properties(properties.len() as u32);213214		with_weight(215			<Pallet<T>>::set_collection_properties(self, &sender, properties),216			weight,217		)218	}219220	fn delete_collection_properties(221		&self,222		sender: &T::CrossAccountId,223		property_keys: Vec<PropertyKey>,224	) -> DispatchResultWithPostInfo {225		let weight = <CommonWeights<T>>::delete_collection_properties(property_keys.len() as u32);226227		with_weight(228			<Pallet<T>>::delete_collection_properties(self, sender, property_keys),229			weight,230		)231	}232233	fn set_token_properties(234		&self,235		sender: T::CrossAccountId,236		token_id: TokenId,237		properties: Vec<Property>,238		nesting_budget: &dyn Budget,239	) -> DispatchResultWithPostInfo {240		let weight = <CommonWeights<T>>::set_token_properties(properties.len() as u32);241242		with_weight(243			<Pallet<T>>::set_token_properties(244				self,245				&sender,246				token_id,247				properties.into_iter(),248				false,249				nesting_budget,250			),251			weight,252		)253	}254255	fn delete_token_properties(256		&self,257		sender: T::CrossAccountId,258		token_id: TokenId,259		property_keys: Vec<PropertyKey>,260		nesting_budget: &dyn Budget,261	) -> DispatchResultWithPostInfo {262		let weight = <CommonWeights<T>>::delete_token_properties(property_keys.len() as u32);263264		with_weight(265			<Pallet<T>>::delete_token_properties(266				self,267				&sender,268				token_id,269				property_keys.into_iter(),270				nesting_budget,271			),272			weight,273		)274	}275276	fn set_token_property_permissions(277		&self,278		sender: &T::CrossAccountId,279		property_permissions: Vec<PropertyKeyPermission>,280	) -> DispatchResultWithPostInfo {281		let weight =282			<CommonWeights<T>>::set_token_property_permissions(property_permissions.len() as u32);283284		with_weight(285			<Pallet<T>>::set_token_property_permissions(self, sender, property_permissions),286			weight,287		)288	}289290	fn burn_item(291		&self,292		sender: T::CrossAccountId,293		token: TokenId,294		amount: u128,295	) -> DispatchResultWithPostInfo {296		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);297		if amount == 1 {298			with_weight(299				<Pallet<T>>::burn(self, &sender, token),300				<CommonWeights<T>>::burn_item(),301			)302		} else {303			<Pallet<T>>::check_token_immediate_ownership(self, token, &sender)?;304			Ok(().into())305		}306	}307308	fn burn_item_recursively(309		&self,310		sender: T::CrossAccountId,311		token: TokenId,312		self_budget: &dyn Budget,313		breadth_budget: &dyn Budget,314	) -> DispatchResultWithPostInfo {315		<Pallet<T>>::burn_recursively(self, &sender, token, self_budget, breadth_budget)316	}317318	fn transfer(319		&self,320		from: T::CrossAccountId,321		to: T::CrossAccountId,322		token: TokenId,323		amount: u128,324		nesting_budget: &dyn Budget,325	) -> DispatchResultWithPostInfo {326		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);327		if amount == 1 {328			<Pallet<T>>::transfer(self, &from, &to, token, nesting_budget)329		} else {330			<Pallet<T>>::check_token_immediate_ownership(self, token, &from)?;331			Ok(().into())332		}333	}334335	fn approve(336		&self,337		sender: T::CrossAccountId,338		spender: T::CrossAccountId,339		token: TokenId,340		amount: u128,341	) -> DispatchResultWithPostInfo {342		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);343344		with_weight(345			if amount == 1 {346				<Pallet<T>>::set_allowance(self, &sender, token, Some(&spender))347			} else {348				<Pallet<T>>::set_allowance(self, &sender, token, None)349			},350			<CommonWeights<T>>::approve(),351		)352	}353354	fn approve_from(355		&self,356		sender: T::CrossAccountId,357		from: T::CrossAccountId,358		to: T::CrossAccountId,359		token: TokenId,360		amount: u128,361	) -> DispatchResultWithPostInfo {362		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);363364		with_weight(365			if amount == 1 {366				<Pallet<T>>::set_allowance_from(self, &sender, &from, token, Some(&to))367			} else {368				<Pallet<T>>::set_allowance_from(self, &sender, &from, token, None)369			},370			<CommonWeights<T>>::approve_from(),371		)372	}373374	fn transfer_from(375		&self,376		sender: T::CrossAccountId,377		from: T::CrossAccountId,378		to: 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			<Pallet<T>>::transfer_from(self, &sender, &from, &to, token, nesting_budget)387		} else {388			<Pallet<T>>::check_allowed(self, &sender, &from, token, nesting_budget)?;389390			Ok(().into())391		}392	}393394	fn burn_from(395		&self,396		sender: T::CrossAccountId,397		from: T::CrossAccountId,398		token: TokenId,399		amount: u128,400		nesting_budget: &dyn Budget,401	) -> DispatchResultWithPostInfo {402		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);403404		if amount == 1 {405			with_weight(406				<Pallet<T>>::burn_from(self, &sender, &from, token, nesting_budget),407				<CommonWeights<T>>::burn_from(),408			)409		} else {410			<Pallet<T>>::check_allowed(self, &sender, &from, token, nesting_budget)?;411412			Ok(().into())413		}414	}415416	fn check_nesting(417		&self,418		sender: T::CrossAccountId,419		from: (CollectionId, TokenId),420		under: TokenId,421		nesting_budget: &dyn Budget,422	) -> sp_runtime::DispatchResult {423		<Pallet<T>>::check_nesting(self, sender, from, under, nesting_budget)424	}425426	fn nest(&self, under: TokenId, to_nest: (CollectionId, TokenId)) {427		<Pallet<T>>::nest((self.id, under), to_nest);428	}429430	fn unnest(&self, under: TokenId, to_unnest: (CollectionId, TokenId)) {431		<Pallet<T>>::unnest((self.id, under), to_unnest);432	}433434	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId> {435		<Owned<T>>::iter_prefix((self.id, account))436			.map(|(id, _)| id)437			.collect()438	}439440	fn collection_tokens(&self) -> Vec<TokenId> {441		<TokenData<T>>::iter_prefix((self.id,))442			.map(|(id, _)| id)443			.collect()444	}445446	fn token_exists(&self, token: TokenId) -> bool {447		<Pallet<T>>::token_exists(self, token)448	}449450	fn last_token_id(&self) -> TokenId {451		TokenId(<TokensMinted<T>>::get(self.id))452	}453454	fn token_owner(&self, token: TokenId) -> Result<T::CrossAccountId, TokenOwnerError> {455		<TokenData<T>>::get((self.id, token))456			.map(|t| t.owner)457			.ok_or(TokenOwnerError::NotFound)458	}459460	/// Returns token owners.461	fn token_owners(&self, token: TokenId) -> Vec<T::CrossAccountId> {462		self.token_owner(token).map_or_else(|_| vec![], |t| vec![t])463	}464465	fn token_property(&self, token_id: TokenId, key: &PropertyKey) -> Option<PropertyValue> {466		<Pallet<T>>::token_properties((self.id, token_id))467			.get(key)468			.cloned()469	}470471	fn token_properties(&self, token_id: TokenId, keys: Option<Vec<PropertyKey>>) -> Vec<Property> {472		let properties = <Pallet<T>>::token_properties((self.id, token_id));473474		keys.map(|keys| {475			keys.into_iter()476				.filter_map(|key| {477					properties.get(&key).map(|value| Property {478						key,479						value: value.clone(),480					})481				})482				.collect()483		})484		.unwrap_or_else(|| {485			properties486				.into_iter()487				.map(|(key, value)| Property { key, value })488				.collect()489		})490	}491492	fn total_supply(&self) -> u32 {493		<Pallet<T>>::total_supply(self)494	}495496	fn account_balance(&self, account: T::CrossAccountId) -> u32 {497		<AccountBalance<T>>::get((self.id, account))498	}499500	fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128 {501		if <TokenData<T>>::get((self.id, token))502			.map(|a| a.owner == account)503			.unwrap_or(false)504		{505			1506		} else {507			0508		}509	}510511	fn allowance(512		&self,513		sender: T::CrossAccountId,514		spender: T::CrossAccountId,515		token: TokenId,516	) -> u128 {517		if <TokenData<T>>::get((self.id, token))518			.map(|a| a.owner != sender)519			.unwrap_or(true)520		{521			0522		} else if <Allowance<T>>::get((self.id, token)) == Some(spender) {523			1524		} else {525			0526		}527	}528529	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>> {530		None531	}532533	fn total_pieces(&self, token: TokenId) -> Option<u128> {534		if <TokenData<T>>::contains_key((self.id, token)) {535			Some(1)536		} else {537			None538		}539	}540541	fn set_allowance_for_all(542		&self,543		owner: T::CrossAccountId,544		operator: T::CrossAccountId,545		approve: bool,546	) -> DispatchResultWithPostInfo {547		with_weight(548			<Pallet<T>>::set_allowance_for_all(self, &owner, &operator, approve),549			<CommonWeights<T>>::set_allowance_for_all(),550		)551	}552553	fn allowance_for_all(&self, owner: T::CrossAccountId, operator: T::CrossAccountId) -> bool {554		<Pallet<T>>::allowance_for_all(self, &owner, &operator)555	}556557	fn repair_item(&self, token: TokenId) -> DispatchResultWithPostInfo {558		with_weight(559			<Pallet<T>>::repair_item(self, token),560			<CommonWeights<T>>::force_repair_item(),561		)562	}563}