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

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 _,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()95	}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		<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_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			with_weight(329				<Pallet<T>>::transfer(self, &from, &to, token, nesting_budget),330				<CommonWeights<T>>::transfer(),331			)332		} else {333			<Pallet<T>>::check_token_immediate_ownership(self, token, &from)?;334			Ok(().into())335		}336	}337338	fn approve(339		&self,340		sender: T::CrossAccountId,341		spender: T::CrossAccountId,342		token: TokenId,343		amount: u128,344	) -> DispatchResultWithPostInfo {345		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);346347		with_weight(348			if amount == 1 {349				<Pallet<T>>::set_allowance(self, &sender, token, Some(&spender))350			} else {351				<Pallet<T>>::set_allowance(self, &sender, token, None)352			},353			<CommonWeights<T>>::approve(),354		)355	}356357	fn approve_from(358		&self,359		sender: T::CrossAccountId,360		from: T::CrossAccountId,361		to: T::CrossAccountId,362		token: TokenId,363		amount: u128,364	) -> DispatchResultWithPostInfo {365		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);366367		with_weight(368			if amount == 1 {369				<Pallet<T>>::set_allowance_from(self, &sender, &from, token, Some(&to))370			} else {371				<Pallet<T>>::set_allowance_from(self, &sender, &from, token, None)372			},373			<CommonWeights<T>>::approve_from(),374		)375	}376377	fn transfer_from(378		&self,379		sender: T::CrossAccountId,380		from: T::CrossAccountId,381		to: T::CrossAccountId,382		token: TokenId,383		amount: u128,384		nesting_budget: &dyn Budget,385	) -> DispatchResultWithPostInfo {386		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);387388		if amount == 1 {389			with_weight(390				<Pallet<T>>::transfer_from(self, &sender, &from, &to, token, nesting_budget),391				<CommonWeights<T>>::transfer_from(),392			)393		} else {394			<Pallet<T>>::check_allowed(self, &sender, &from, token, nesting_budget)?;395396			Ok(().into())397		}398	}399400	fn burn_from(401		&self,402		sender: T::CrossAccountId,403		from: T::CrossAccountId,404		token: TokenId,405		amount: u128,406		nesting_budget: &dyn Budget,407	) -> DispatchResultWithPostInfo {408		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);409410		if amount == 1 {411			with_weight(412				<Pallet<T>>::burn_from(self, &sender, &from, token, nesting_budget),413				<CommonWeights<T>>::burn_from(),414			)415		} else {416			<Pallet<T>>::check_allowed(self, &sender, &from, token, nesting_budget)?;417418			Ok(().into())419		}420	}421422	fn check_nesting(423		&self,424		sender: T::CrossAccountId,425		from: (CollectionId, TokenId),426		under: TokenId,427		nesting_budget: &dyn Budget,428	) -> sp_runtime::DispatchResult {429		<Pallet<T>>::check_nesting(self, sender, from, under, nesting_budget)430	}431432	fn nest(&self, under: TokenId, to_nest: (CollectionId, TokenId)) {433		<Pallet<T>>::nest((self.id, under), to_nest);434	}435436	fn unnest(&self, under: TokenId, to_unnest: (CollectionId, TokenId)) {437		<Pallet<T>>::unnest((self.id, under), to_unnest);438	}439440	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId> {441		<Owned<T>>::iter_prefix((self.id, account))442			.map(|(id, _)| id)443			.collect()444	}445446	fn collection_tokens(&self) -> Vec<TokenId> {447		<TokenData<T>>::iter_prefix((self.id,))448			.map(|(id, _)| id)449			.collect()450	}451452	fn token_exists(&self, token: TokenId) -> bool {453		<Pallet<T>>::token_exists(self, token)454	}455456	fn last_token_id(&self) -> TokenId {457		TokenId(<TokensMinted<T>>::get(self.id))458	}459460	fn token_owner(&self, token: TokenId) -> Result<T::CrossAccountId, TokenOwnerError> {461		<TokenData<T>>::get((self.id, token))462			.map(|t| t.owner)463			.ok_or(TokenOwnerError::NotFound)464	}465466	/// Returns token owners.467	fn token_owners(&self, token: TokenId) -> Vec<T::CrossAccountId> {468		self.token_owner(token).map_or_else(|_| vec![], |t| vec![t])469	}470471	fn token_property(&self, token_id: TokenId, key: &PropertyKey) -> Option<PropertyValue> {472		<Pallet<T>>::token_properties((self.id, token_id))473			.get(key)474			.cloned()475	}476477	fn token_properties(&self, token_id: TokenId, keys: Option<Vec<PropertyKey>>) -> Vec<Property> {478		let properties = <Pallet<T>>::token_properties((self.id, token_id));479480		keys.map(|keys| {481			keys.into_iter()482				.filter_map(|key| {483					properties.get(&key).map(|value| Property {484						key,485						value: value.clone(),486					})487				})488				.collect()489		})490		.unwrap_or_else(|| {491			properties492				.into_iter()493				.map(|(key, value)| Property { key, value })494				.collect()495		})496	}497498	fn total_supply(&self) -> u32 {499		<Pallet<T>>::total_supply(self)500	}501502	fn account_balance(&self, account: T::CrossAccountId) -> u32 {503		<AccountBalance<T>>::get((self.id, account))504	}505506	fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128 {507		if <TokenData<T>>::get((self.id, token))508			.map(|a| a.owner == account)509			.unwrap_or(false)510		{511			1512		} else {513			0514		}515	}516517	fn allowance(518		&self,519		sender: T::CrossAccountId,520		spender: T::CrossAccountId,521		token: TokenId,522	) -> u128 {523		if <TokenData<T>>::get((self.id, token))524			.map(|a| a.owner != sender)525			.unwrap_or(true)526		{527			0528		} else if <Allowance<T>>::get((self.id, token)) == Some(spender) {529			1530		} else {531			0532		}533	}534535	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>> {536		None537	}538539	fn total_pieces(&self, token: TokenId) -> Option<u128> {540		if <TokenData<T>>::contains_key((self.id, token)) {541			Some(1)542		} else {543			None544		}545	}546547	fn set_allowance_for_all(548		&self,549		owner: T::CrossAccountId,550		operator: T::CrossAccountId,551		approve: bool,552	) -> DispatchResultWithPostInfo {553		with_weight(554			<Pallet<T>>::set_allowance_for_all(self, &owner, &operator, approve),555			<CommonWeights<T>>::set_allowance_for_all(),556		)557	}558559	fn allowance_for_all(&self, owner: T::CrossAccountId, operator: T::CrossAccountId) -> bool {560		<Pallet<T>>::allowance_for_all(self, &owner, &operator)561	}562563	fn repair_item(&self, token: TokenId) -> DispatchResultWithPostInfo {564		with_weight(565			<Pallet<T>>::repair_item(self, token),566			<CommonWeights<T>>::force_repair_item(),567		)568	}569}