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

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		nesting_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(229				self,230				&sender,231				token_id,232				properties.into_iter(),233				false,234				nesting_budget,235			),236			weight,237		)238	}239240	fn delete_token_properties(241		&self,242		sender: T::CrossAccountId,243		token_id: TokenId,244		property_keys: Vec<PropertyKey>,245		nesting_budget: &dyn Budget,246	) -> DispatchResultWithPostInfo {247		let weight = <CommonWeights<T>>::delete_token_properties(property_keys.len() as u32);248249		with_weight(250			<Pallet<T>>::delete_token_properties(251				self,252				&sender,253				token_id,254				property_keys.into_iter(),255				nesting_budget,256			),257			weight,258		)259	}260261	fn set_token_property_permissions(262		&self,263		sender: &T::CrossAccountId,264		property_permissions: Vec<PropertyKeyPermission>,265	) -> DispatchResultWithPostInfo {266		let weight =267			<CommonWeights<T>>::set_token_property_permissions(property_permissions.len() as u32);268269		with_weight(270			<Pallet<T>>::set_token_property_permissions(self, sender, property_permissions),271			weight,272		)273	}274275	fn burn_item(276		&self,277		sender: T::CrossAccountId,278		token: TokenId,279		amount: u128,280	) -> DispatchResultWithPostInfo {281		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);282		if amount == 1 {283			with_weight(284				<Pallet<T>>::burn(self, &sender, token),285				<CommonWeights<T>>::burn_item(),286			)287		} else {288			Ok(().into())289		}290	}291292	fn burn_item_recursively(293		&self,294		sender: T::CrossAccountId,295		token: TokenId,296		self_budget: &dyn Budget,297		breadth_budget: &dyn Budget,298	) -> DispatchResultWithPostInfo {299		<Pallet<T>>::burn_recursively(self, &sender, token, self_budget, breadth_budget)300	}301302	fn transfer(303		&self,304		from: T::CrossAccountId,305		to: T::CrossAccountId,306		token: TokenId,307		amount: u128,308		nesting_budget: &dyn Budget,309	) -> DispatchResultWithPostInfo {310		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);311		if amount == 1 {312			with_weight(313				<Pallet<T>>::transfer(self, &from, &to, token, nesting_budget),314				<CommonWeights<T>>::transfer(),315			)316		} else {317			Ok(().into())318		}319	}320321	fn approve(322		&self,323		sender: T::CrossAccountId,324		spender: T::CrossAccountId,325		token: TokenId,326		amount: u128,327	) -> DispatchResultWithPostInfo {328		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);329330		with_weight(331			if amount == 1 {332				<Pallet<T>>::set_allowance(self, &sender, token, Some(&spender))333			} else {334				<Pallet<T>>::set_allowance(self, &sender, token, None)335			},336			<CommonWeights<T>>::approve(),337		)338	}339340	fn transfer_from(341		&self,342		sender: T::CrossAccountId,343		from: T::CrossAccountId,344		to: T::CrossAccountId,345		token: TokenId,346		amount: u128,347		nesting_budget: &dyn Budget,348	) -> DispatchResultWithPostInfo {349		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);350351		if amount == 1 {352			with_weight(353				<Pallet<T>>::transfer_from(self, &sender, &from, &to, token, nesting_budget),354				<CommonWeights<T>>::transfer_from(),355			)356		} else {357			Ok(().into())358		}359	}360361	fn burn_from(362		&self,363		sender: T::CrossAccountId,364		from: T::CrossAccountId,365		token: TokenId,366		amount: u128,367		nesting_budget: &dyn Budget,368	) -> DispatchResultWithPostInfo {369		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);370371		if amount == 1 {372			with_weight(373				<Pallet<T>>::burn_from(self, &sender, &from, token, nesting_budget),374				<CommonWeights<T>>::burn_from(),375			)376		} else {377			Ok(().into())378		}379	}380381	fn check_nesting(382		&self,383		sender: T::CrossAccountId,384		from: (CollectionId, TokenId),385		under: TokenId,386		nesting_budget: &dyn Budget,387	) -> sp_runtime::DispatchResult {388		<Pallet<T>>::check_nesting(self, sender, from, under, nesting_budget)389	}390391	fn nest(&self, under: TokenId, to_nest: (CollectionId, TokenId)) {392		<Pallet<T>>::nest((self.id, under), to_nest);393	}394395	fn unnest(&self, under: TokenId, to_unnest: (CollectionId, TokenId)) {396		<Pallet<T>>::unnest((self.id, under), to_unnest);397	}398399	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId> {400		<Owned<T>>::iter_prefix((self.id, account))401			.map(|(id, _)| id)402			.collect()403	}404405	fn collection_tokens(&self) -> Vec<TokenId> {406		<TokenData<T>>::iter_prefix((self.id,))407			.map(|(id, _)| id)408			.collect()409	}410411	fn token_exists(&self, token: TokenId) -> bool {412		<Pallet<T>>::token_exists(self, token)413	}414415	fn last_token_id(&self) -> TokenId {416		TokenId(<TokensMinted<T>>::get(self.id))417	}418419	fn token_owner(&self, token: TokenId) -> Option<T::CrossAccountId> {420		<TokenData<T>>::get((self.id, token)).map(|t| t.owner)421	}422423	fn token_property(&self, token_id: TokenId, key: &PropertyKey) -> Option<PropertyValue> {424		<Pallet<T>>::token_properties((self.id, token_id))425			.get(key)426			.cloned()427	}428429	fn token_properties(&self, token_id: TokenId, keys: Option<Vec<PropertyKey>>) -> Vec<Property> {430		let properties = <Pallet<T>>::token_properties((self.id, token_id));431432		keys.map(|keys| {433			keys.into_iter()434				.filter_map(|key| {435					properties.get(&key).map(|value| Property {436						key,437						value: value.clone(),438					})439				})440				.collect()441		})442		.unwrap_or_else(|| {443			properties444				.into_iter()445				.map(|(key, value)| Property { key, value })446				.collect()447		})448	}449450	fn total_supply(&self) -> u32 {451		<Pallet<T>>::total_supply(self)452	}453454	fn account_balance(&self, account: T::CrossAccountId) -> u32 {455		<AccountBalance<T>>::get((self.id, account))456	}457458	fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128 {459		if <TokenData<T>>::get((self.id, token))460			.map(|a| a.owner == account)461			.unwrap_or(false)462		{463			1464		} else {465			0466		}467	}468469	fn allowance(470		&self,471		sender: T::CrossAccountId,472		spender: T::CrossAccountId,473		token: TokenId,474	) -> u128 {475		if <TokenData<T>>::get((self.id, token))476			.map(|a| a.owner != sender)477			.unwrap_or(true)478		{479			0480		} else if <Allowance<T>>::get((self.id, token)) == Some(spender) {481			1482		} else {483			0484		}485	}486487	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>> {488		None489	}490}