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

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	}125}126127fn map_create_data<T: Config>(128	data: up_data_structs::CreateItemData,129	to: &T::CrossAccountId,130) -> Result<CreateItemData<T>, DispatchError> {131	match data {132		up_data_structs::CreateItemData::NFT(data) => Ok(CreateItemData::<T> {133			properties: data.properties,134			owner: to.clone(),135		}),136		_ => fail!(<Error<T>>::NotNonfungibleDataUsedToMintFungibleCollectionToken),137	}138}139140/// Implementation of `CommonCollectionOperations` for `NonfungibleHandle`. It wraps Nonfungible Pallete141/// methods and adds weight info.142impl<T: Config> CommonCollectionOperations<T> for NonfungibleHandle<T> {143	fn create_item(144		&self,145		sender: T::CrossAccountId,146		to: T::CrossAccountId,147		data: up_data_structs::CreateItemData,148		nesting_budget: &dyn Budget,149	) -> DispatchResultWithPostInfo {150		with_weight(151			<Pallet<T>>::create_item(152				self,153				&sender,154				map_create_data::<T>(data, &to)?,155				nesting_budget,156			),157			<CommonWeights<T>>::create_item(),158		)159	}160161	fn create_multiple_items(162		&self,163		sender: T::CrossAccountId,164		to: T::CrossAccountId,165		data: Vec<up_data_structs::CreateItemData>,166		nesting_budget: &dyn Budget,167	) -> DispatchResultWithPostInfo {168		let weight = <CommonWeights<T>>::create_multiple_items(&data);169		let data = data170			.into_iter()171			.map(|d| map_create_data::<T>(d, &to))172			.collect::<Result<Vec<_>, DispatchError>>()?;173174		with_weight(175			<Pallet<T>>::create_multiple_items(self, &sender, data, nesting_budget),176			weight,177		)178	}179180	fn create_multiple_items_ex(181		&self,182		sender: <T>::CrossAccountId,183		data: up_data_structs::CreateItemExData<<T>::CrossAccountId>,184		nesting_budget: &dyn Budget,185	) -> DispatchResultWithPostInfo {186		let weight = <CommonWeights<T>>::create_multiple_items_ex(&data);187		let data = match data {188			up_data_structs::CreateItemExData::NFT(nft) => nft,189			_ => fail!(Error::<T>::NotNonfungibleDataUsedToMintFungibleCollectionToken),190		};191192		with_weight(193			<Pallet<T>>::create_multiple_items(self, &sender, data.into_inner(), nesting_budget),194			weight,195		)196	}197198	fn set_collection_properties(199		&self,200		sender: T::CrossAccountId,201		properties: Vec<Property>,202	) -> DispatchResultWithPostInfo {203		let weight = <CommonWeights<T>>::set_collection_properties(properties.len() as u32);204205		with_weight(206			<Pallet<T>>::set_collection_properties(self, &sender, properties),207			weight,208		)209	}210211	fn delete_collection_properties(212		&self,213		sender: &T::CrossAccountId,214		property_keys: Vec<PropertyKey>,215	) -> DispatchResultWithPostInfo {216		let weight = <CommonWeights<T>>::delete_collection_properties(property_keys.len() as u32);217218		with_weight(219			<Pallet<T>>::delete_collection_properties(self, sender, property_keys),220			weight,221		)222	}223224	fn set_token_properties(225		&self,226		sender: T::CrossAccountId,227		token_id: TokenId,228		properties: Vec<Property>,229		nesting_budget: &dyn Budget,230	) -> DispatchResultWithPostInfo {231		let weight = <CommonWeights<T>>::set_token_properties(properties.len() as u32);232233		with_weight(234			<Pallet<T>>::set_token_properties(235				self,236				&sender,237				token_id,238				properties.into_iter(),239				false,240				nesting_budget,241			),242			weight,243		)244	}245246	fn delete_token_properties(247		&self,248		sender: T::CrossAccountId,249		token_id: TokenId,250		property_keys: Vec<PropertyKey>,251		nesting_budget: &dyn Budget,252	) -> DispatchResultWithPostInfo {253		let weight = <CommonWeights<T>>::delete_token_properties(property_keys.len() as u32);254255		with_weight(256			<Pallet<T>>::delete_token_properties(257				self,258				&sender,259				token_id,260				property_keys.into_iter(),261				nesting_budget,262			),263			weight,264		)265	}266267	fn set_token_property_permissions(268		&self,269		sender: &T::CrossAccountId,270		property_permissions: Vec<PropertyKeyPermission>,271	) -> DispatchResultWithPostInfo {272		let weight =273			<CommonWeights<T>>::set_token_property_permissions(property_permissions.len() as u32);274275		with_weight(276			<Pallet<T>>::set_token_property_permissions(self, sender, property_permissions),277			weight,278		)279	}280281	fn burn_item(282		&self,283		sender: T::CrossAccountId,284		token: TokenId,285		amount: u128,286	) -> DispatchResultWithPostInfo {287		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);288		if amount == 1 {289			with_weight(290				<Pallet<T>>::burn(self, &sender, token),291				<CommonWeights<T>>::burn_item(),292			)293		} else {294			<Pallet<T>>::check_token_immediate_ownership(self, token, &sender)?;295			Ok(().into())296		}297	}298299	fn burn_item_recursively(300		&self,301		sender: T::CrossAccountId,302		token: TokenId,303		self_budget: &dyn Budget,304		breadth_budget: &dyn Budget,305	) -> DispatchResultWithPostInfo {306		<Pallet<T>>::burn_recursively(self, &sender, token, self_budget, breadth_budget)307	}308309	fn transfer(310		&self,311		from: T::CrossAccountId,312		to: T::CrossAccountId,313		token: TokenId,314		amount: u128,315		nesting_budget: &dyn Budget,316	) -> DispatchResultWithPostInfo {317		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);318		if amount == 1 {319			with_weight(320				<Pallet<T>>::transfer(self, &from, &to, token, nesting_budget),321				<CommonWeights<T>>::transfer(),322			)323		} else {324			<Pallet<T>>::check_token_immediate_ownership(self, token, &from)?;325			Ok(().into())326		}327	}328329	fn approve(330		&self,331		sender: T::CrossAccountId,332		spender: T::CrossAccountId,333		token: TokenId,334		amount: u128,335	) -> DispatchResultWithPostInfo {336		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);337338		with_weight(339			if amount == 1 {340				<Pallet<T>>::set_allowance(self, &sender, token, Some(&spender))341			} else {342				<Pallet<T>>::set_allowance(self, &sender, token, None)343			},344			<CommonWeights<T>>::approve(),345		)346	}347348	fn transfer_from(349		&self,350		sender: T::CrossAccountId,351		from: T::CrossAccountId,352		to: T::CrossAccountId,353		token: TokenId,354		amount: u128,355		nesting_budget: &dyn Budget,356	) -> DispatchResultWithPostInfo {357		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);358359		if amount == 1 {360			with_weight(361				<Pallet<T>>::transfer_from(self, &sender, &from, &to, token, nesting_budget),362				<CommonWeights<T>>::transfer_from(),363			)364		} else {365			<Pallet<T>>::check_allowed(self, &sender, &from, token, nesting_budget)?;366367			Ok(().into())368		}369	}370371	fn burn_from(372		&self,373		sender: T::CrossAccountId,374		from: T::CrossAccountId,375		token: TokenId,376		amount: u128,377		nesting_budget: &dyn Budget,378	) -> DispatchResultWithPostInfo {379		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);380381		if amount == 1 {382			with_weight(383				<Pallet<T>>::burn_from(self, &sender, &from, token, nesting_budget),384				<CommonWeights<T>>::burn_from(),385			)386		} else {387			<Pallet<T>>::check_allowed(self, &sender, &from, token, nesting_budget)?;388389			Ok(().into())390		}391	}392393	fn check_nesting(394		&self,395		sender: T::CrossAccountId,396		from: (CollectionId, TokenId),397		under: TokenId,398		nesting_budget: &dyn Budget,399	) -> sp_runtime::DispatchResult {400		<Pallet<T>>::check_nesting(self, sender, from, under, nesting_budget)401	}402403	fn nest(&self, under: TokenId, to_nest: (CollectionId, TokenId)) {404		<Pallet<T>>::nest((self.id, under), to_nest);405	}406407	fn unnest(&self, under: TokenId, to_unnest: (CollectionId, TokenId)) {408		<Pallet<T>>::unnest((self.id, under), to_unnest);409	}410411	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId> {412		<Owned<T>>::iter_prefix((self.id, account))413			.map(|(id, _)| id)414			.collect()415	}416417	fn collection_tokens(&self) -> Vec<TokenId> {418		<TokenData<T>>::iter_prefix((self.id,))419			.map(|(id, _)| id)420			.collect()421	}422423	fn token_exists(&self, token: TokenId) -> bool {424		<Pallet<T>>::token_exists(self, token)425	}426427	fn last_token_id(&self) -> TokenId {428		TokenId(<TokensMinted<T>>::get(self.id))429	}430431	fn token_owner(&self, token: TokenId) -> Option<T::CrossAccountId> {432		<TokenData<T>>::get((self.id, token)).map(|t| t.owner)433	}434435	/// Returns token owners.436	fn token_owners(&self, token: TokenId) -> Vec<T::CrossAccountId> {437		self.token_owner(token).map_or_else(|| vec![], |t| vec![t])438	}439440	fn token_property(&self, token_id: TokenId, key: &PropertyKey) -> Option<PropertyValue> {441		<Pallet<T>>::token_properties((self.id, token_id))442			.get(key)443			.cloned()444	}445446	fn token_properties(&self, token_id: TokenId, keys: Option<Vec<PropertyKey>>) -> Vec<Property> {447		let properties = <Pallet<T>>::token_properties((self.id, token_id));448449		keys.map(|keys| {450			keys.into_iter()451				.filter_map(|key| {452					properties.get(&key).map(|value| Property {453						key,454						value: value.clone(),455					})456				})457				.collect()458		})459		.unwrap_or_else(|| {460			properties461				.into_iter()462				.map(|(key, value)| Property { key, value })463				.collect()464		})465	}466467	fn total_supply(&self) -> u32 {468		<Pallet<T>>::total_supply(self)469	}470471	fn account_balance(&self, account: T::CrossAccountId) -> u32 {472		<AccountBalance<T>>::get((self.id, account))473	}474475	fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128 {476		if <TokenData<T>>::get((self.id, token))477			.map(|a| a.owner == account)478			.unwrap_or(false)479		{480			1481		} else {482			0483		}484	}485486	fn allowance(487		&self,488		sender: T::CrossAccountId,489		spender: T::CrossAccountId,490		token: TokenId,491	) -> u128 {492		if <TokenData<T>>::get((self.id, token))493			.map(|a| a.owner != sender)494			.unwrap_or(true)495		{496			0497		} else if <Allowance<T>>::get((self.id, token)) == Some(spender) {498			1499		} else {500			0501		}502	}503504	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>> {505		None506	}507508	fn total_pieces(&self, token: TokenId) -> Option<u128> {509		if <TokenData<T>>::contains_key((self.id, token)) {510			Some(1)511		} else {512			None513		}514	}515}