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

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;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						.map(|t| {48							if t.properties.len() > 0 {49								Self::set_token_properties(t.properties.len() as u32)50							} else {51								052							}53						})54						.sum::<u64>()55			}56			_ => 0,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				.sum::<u64>()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	}121}122123fn map_create_data<T: Config>(124	data: up_data_structs::CreateItemData,125	to: &T::CrossAccountId,126) -> Result<CreateItemData<T>, DispatchError> {127	match data {128		up_data_structs::CreateItemData::NFT(data) => Ok(CreateItemData::<T> {129			properties: data.properties,130			owner: to.clone(),131		}),132		_ => fail!(<Error<T>>::NotNonfungibleDataUsedToMintFungibleCollectionToken),133	}134}135136impl<T: Config> CommonCollectionOperations<T> for NonfungibleHandle<T> {137	fn create_item(138		&self,139		sender: T::CrossAccountId,140		to: T::CrossAccountId,141		data: up_data_structs::CreateItemData,142		nesting_budget: &dyn Budget,143	) -> DispatchResultWithPostInfo {144		with_weight(145			<Pallet<T>>::create_item(146				self,147				&sender,148				map_create_data::<T>(data, &to)?,149				nesting_budget,150			),151			<CommonWeights<T>>::create_item(),152		)153	}154155	fn create_multiple_items(156		&self,157		sender: T::CrossAccountId,158		to: T::CrossAccountId,159		data: Vec<up_data_structs::CreateItemData>,160		nesting_budget: &dyn Budget,161	) -> DispatchResultWithPostInfo {162		let weight = <CommonWeights<T>>::create_multiple_items(&data);163		let data = data164			.into_iter()165			.map(|d| map_create_data::<T>(d, &to))166			.collect::<Result<Vec<_>, DispatchError>>()?;167168		with_weight(169			<Pallet<T>>::create_multiple_items(self, &sender, data, nesting_budget),170			weight,171		)172	}173174	fn create_multiple_items_ex(175		&self,176		sender: <T>::CrossAccountId,177		data: up_data_structs::CreateItemExData<<T>::CrossAccountId>,178		nesting_budget: &dyn Budget,179	) -> DispatchResultWithPostInfo {180		let weight = <CommonWeights<T>>::create_multiple_items_ex(&data);181		let data = match data {182			up_data_structs::CreateItemExData::NFT(nft) => nft,183			_ => fail!(Error::<T>::NotNonfungibleDataUsedToMintFungibleCollectionToken),184		};185186		with_weight(187			<Pallet<T>>::create_multiple_items(self, &sender, data.into_inner(), nesting_budget),188			weight,189		)190	}191192	fn set_collection_properties(193		&self,194		sender: T::CrossAccountId,195		properties: Vec<Property>,196	) -> DispatchResultWithPostInfo {197		let weight = <CommonWeights<T>>::set_collection_properties(properties.len() as u32);198199		with_weight(200			<Pallet<T>>::set_collection_properties(self, &sender, properties),201			weight,202		)203	}204205	fn delete_collection_properties(206		&self,207		sender: &T::CrossAccountId,208		property_keys: Vec<PropertyKey>,209	) -> DispatchResultWithPostInfo {210		let weight = <CommonWeights<T>>::delete_collection_properties(property_keys.len() as u32);211212		with_weight(213			<Pallet<T>>::delete_collection_properties(self, sender, property_keys),214			weight,215		)216	}217218	fn set_token_properties(219		&self,220		sender: T::CrossAccountId,221		token_id: TokenId,222		properties: Vec<Property>,223		budget: &dyn Budget,224	) -> DispatchResultWithPostInfo {225		let weight = <CommonWeights<T>>::set_token_properties(properties.len() as u32);226227		with_weight(228			<Pallet<T>>::set_token_properties(self, &sender, token_id, properties, false, budget),229			weight,230		)231	}232233	fn delete_token_properties(234		&self,235		sender: T::CrossAccountId,236		token_id: TokenId,237		property_keys: Vec<PropertyKey>,238		budget: &dyn Budget,239	) -> DispatchResultWithPostInfo {240		let weight = <CommonWeights<T>>::delete_token_properties(property_keys.len() as u32);241242		with_weight(243			<Pallet<T>>::delete_token_properties(self, &sender, token_id, property_keys, budget),244			weight,245		)246	}247248	fn set_token_property_permissions(249		&self,250		sender: &T::CrossAccountId,251		property_permissions: Vec<PropertyKeyPermission>,252	) -> DispatchResultWithPostInfo {253		let weight =254			<CommonWeights<T>>::set_token_property_permissions(property_permissions.len() as u32);255256		with_weight(257			<Pallet<T>>::set_token_property_permissions(self, sender, property_permissions),258			weight,259		)260	}261262	fn burn_item(263		&self,264		sender: T::CrossAccountId,265		token: TokenId,266		amount: u128,267	) -> DispatchResultWithPostInfo {268		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);269		if amount == 1 {270			with_weight(271				<Pallet<T>>::burn(self, &sender, token),272				<CommonWeights<T>>::burn_item(),273			)274		} else {275			Ok(().into())276		}277	}278279	fn burn_item_recursively(280		&self,281		sender: T::CrossAccountId,282		token: TokenId,283		self_budget: &dyn Budget,284		breadth_budget: &dyn Budget,285	) -> DispatchResultWithPostInfo {286		<Pallet<T>>::burn_recursively(self, &sender, token, self_budget, breadth_budget)287	}288289	fn transfer(290		&self,291		from: T::CrossAccountId,292		to: T::CrossAccountId,293		token: TokenId,294		amount: u128,295		nesting_budget: &dyn Budget,296	) -> DispatchResultWithPostInfo {297		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);298		if amount == 1 {299			with_weight(300				<Pallet<T>>::transfer(self, &from, &to, token, nesting_budget),301				<CommonWeights<T>>::transfer(),302			)303		} else {304			Ok(().into())305		}306	}307308	fn approve(309		&self,310		sender: T::CrossAccountId,311		spender: T::CrossAccountId,312		token: TokenId,313		amount: u128,314	) -> DispatchResultWithPostInfo {315		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);316317		with_weight(318			if amount == 1 {319				<Pallet<T>>::set_allowance(self, &sender, token, Some(&spender))320			} else {321				<Pallet<T>>::set_allowance(self, &sender, token, None)322			},323			<CommonWeights<T>>::approve(),324		)325	}326327	fn transfer_from(328		&self,329		sender: T::CrossAccountId,330		from: T::CrossAccountId,331		to: T::CrossAccountId,332		token: TokenId,333		amount: u128,334		nesting_budget: &dyn Budget,335	) -> DispatchResultWithPostInfo {336		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);337338		if amount == 1 {339			with_weight(340				<Pallet<T>>::transfer_from(self, &sender, &from, &to, token, nesting_budget),341				<CommonWeights<T>>::transfer_from(),342			)343		} else {344			Ok(().into())345		}346	}347348	fn burn_from(349		&self,350		sender: T::CrossAccountId,351		from: T::CrossAccountId,352		token: TokenId,353		amount: u128,354		nesting_budget: &dyn Budget,355	) -> DispatchResultWithPostInfo {356		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);357358		if amount == 1 {359			with_weight(360				<Pallet<T>>::burn_from(self, &sender, &from, token, nesting_budget),361				<CommonWeights<T>>::burn_from(),362			)363		} else {364			Ok(().into())365		}366	}367368	fn check_nesting(369		&self,370		sender: T::CrossAccountId,371		from: (CollectionId, TokenId),372		under: TokenId,373		budget: &dyn Budget,374	) -> sp_runtime::DispatchResult {375		<Pallet<T>>::check_nesting(self, sender, from, under, budget)376	}377378	fn nest(&self, under: TokenId, to_nest: (CollectionId, TokenId)) {379		<Pallet<T>>::nest((self.id, under), to_nest);380	}381382	fn unnest(&self, under: TokenId, to_unnest: (CollectionId, TokenId)) {383		<Pallet<T>>::unnest((self.id, under), to_unnest);384	}385386	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId> {387		<Owned<T>>::iter_prefix((self.id, account))388			.map(|(id, _)| id)389			.collect()390	}391392	fn collection_tokens(&self) -> Vec<TokenId> {393		<TokenData<T>>::iter_prefix((self.id,))394			.map(|(id, _)| id)395			.collect()396	}397398	fn token_exists(&self, token: TokenId) -> bool {399		<Pallet<T>>::token_exists(self, token)400	}401402	fn last_token_id(&self) -> TokenId {403		TokenId(<TokensMinted<T>>::get(self.id))404	}405406	fn token_owner(&self, token: TokenId) -> Option<T::CrossAccountId> {407		<TokenData<T>>::get((self.id, token)).map(|t| t.owner)408	}409410	fn token_property(&self, token_id: TokenId, key: &PropertyKey) -> Option<PropertyValue> {411		<Pallet<T>>::token_properties((self.id, token_id))412			.get(key)413			.cloned()414	}415416	fn token_properties(&self, token_id: TokenId, keys: Option<Vec<PropertyKey>>) -> Vec<Property> {417		let properties = <Pallet<T>>::token_properties((self.id, token_id));418419		keys.map(|keys| {420			keys.into_iter()421				.filter_map(|key| {422					properties.get(&key).map(|value| Property {423						key,424						value: value.clone(),425					})426				})427				.collect()428		})429		.unwrap_or_else(|| {430			properties431				.into_iter()432				.map(|(key, value)| Property { key, value })433				.collect()434		})435	}436437	fn total_supply(&self) -> u32 {438		<Pallet<T>>::total_supply(self)439	}440441	fn account_balance(&self, account: T::CrossAccountId) -> u32 {442		<AccountBalance<T>>::get((self.id, account))443	}444445	fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128 {446		if <TokenData<T>>::get((self.id, token))447			.map(|a| a.owner == account)448			.unwrap_or(false)449		{450			1451		} else {452			0453		}454	}455456	fn allowance(457		&self,458		sender: T::CrossAccountId,459		spender: T::CrossAccountId,460		token: TokenId,461	) -> u128 {462		if <TokenData<T>>::get((self.id, token))463			.map(|a| a.owner != sender)464			.unwrap_or(true)465		{466			0467		} else if <Allowance<T>>::get((self.id, token)) == Some(spender) {468			1469		} else {470			0471		}472	}473474	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>> {475		None476	}477}