git.delta.rocks / unique-network / refs/commits / 860bb39fe415

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	) -> DispatchResultWithPostInfo {224		let weight = <CommonWeights<T>>::set_token_properties(properties.len() as u32);225226		with_weight(227			<Pallet<T>>::set_token_properties(self, &sender, token_id, properties, false),228			weight,229		)230	}231232	fn delete_token_properties(233		&self,234		sender: T::CrossAccountId,235		token_id: TokenId,236		property_keys: Vec<PropertyKey>,237	) -> DispatchResultWithPostInfo {238		let weight = <CommonWeights<T>>::delete_token_properties(property_keys.len() as u32);239240		with_weight(241			<Pallet<T>>::delete_token_properties(self, &sender, token_id, property_keys),242			weight,243		)244	}245246	fn set_token_property_permissions(247		&self,248		sender: &T::CrossAccountId,249		property_permissions: Vec<PropertyKeyPermission>,250	) -> DispatchResultWithPostInfo {251		let weight =252			<CommonWeights<T>>::set_token_property_permissions(property_permissions.len() as u32);253254		with_weight(255			<Pallet<T>>::set_token_property_permissions(self, sender, property_permissions),256			weight,257		)258	}259260	fn burn_item(261		&self,262		sender: T::CrossAccountId,263		token: TokenId,264		amount: u128,265	) -> DispatchResultWithPostInfo {266		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);267		if amount == 1 {268			with_weight(269				<Pallet<T>>::burn(self, &sender, token),270				<CommonWeights<T>>::burn_item(),271			)272		} else {273			Ok(().into())274		}275	}276277	fn burn_item_recursively(278		&self,279		sender: T::CrossAccountId,280		token: TokenId,281		self_budget: &dyn Budget,282		breadth_budget: &dyn Budget,283	) -> DispatchResultWithPostInfo {284		<Pallet<T>>::burn_recursively(self, &sender, token, self_budget, breadth_budget)285	}286287	fn transfer(288		&self,289		from: T::CrossAccountId,290		to: T::CrossAccountId,291		token: TokenId,292		amount: u128,293		nesting_budget: &dyn Budget,294	) -> DispatchResultWithPostInfo {295		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);296		if amount == 1 {297			with_weight(298				<Pallet<T>>::transfer(self, &from, &to, token, nesting_budget),299				<CommonWeights<T>>::transfer(),300			)301		} else {302			Ok(().into())303		}304	}305306	fn approve(307		&self,308		sender: T::CrossAccountId,309		spender: T::CrossAccountId,310		token: TokenId,311		amount: u128,312	) -> DispatchResultWithPostInfo {313		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);314315		with_weight(316			if amount == 1 {317				<Pallet<T>>::set_allowance(self, &sender, token, Some(&spender))318			} else {319				<Pallet<T>>::set_allowance(self, &sender, token, None)320			},321			<CommonWeights<T>>::approve(),322		)323	}324325	fn transfer_from(326		&self,327		sender: T::CrossAccountId,328		from: T::CrossAccountId,329		to: T::CrossAccountId,330		token: TokenId,331		amount: u128,332		nesting_budget: &dyn Budget,333	) -> DispatchResultWithPostInfo {334		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);335336		if amount == 1 {337			with_weight(338				<Pallet<T>>::transfer_from(self, &sender, &from, &to, token, nesting_budget),339				<CommonWeights<T>>::transfer_from(),340			)341		} else {342			Ok(().into())343		}344	}345346	fn burn_from(347		&self,348		sender: T::CrossAccountId,349		from: T::CrossAccountId,350		token: TokenId,351		amount: u128,352		nesting_budget: &dyn Budget,353	) -> DispatchResultWithPostInfo {354		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);355356		if amount == 1 {357			with_weight(358				<Pallet<T>>::burn_from(self, &sender, &from, token, nesting_budget),359				<CommonWeights<T>>::burn_from(),360			)361		} else {362			Ok(().into())363		}364	}365366	fn check_nesting(367		&self,368		sender: T::CrossAccountId,369		from: (CollectionId, TokenId),370		under: TokenId,371		budget: &dyn Budget,372	) -> sp_runtime::DispatchResult {373		<Pallet<T>>::check_nesting(self, sender, from, under, budget)374	}375376	fn nest(&self, under: TokenId, to_nest: (CollectionId, TokenId)) {377		<Pallet<T>>::nest((self.id, under), to_nest);378	}379380	fn unnest(&self, under: TokenId, to_unnest: (CollectionId, TokenId)) {381		<Pallet<T>>::unnest((self.id, under), to_unnest);382	}383384	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId> {385		<Owned<T>>::iter_prefix((self.id, account))386			.map(|(id, _)| id)387			.collect()388	}389390	fn collection_tokens(&self) -> Vec<TokenId> {391		<TokenData<T>>::iter_prefix((self.id,))392			.map(|(id, _)| id)393			.collect()394	}395396	fn token_exists(&self, token: TokenId) -> bool {397		<Pallet<T>>::token_exists(self, token)398	}399400	fn last_token_id(&self) -> TokenId {401		TokenId(<TokensMinted<T>>::get(self.id))402	}403404	fn token_owner(&self, token: TokenId) -> Option<T::CrossAccountId> {405		<TokenData<T>>::get((self.id, token)).map(|t| t.owner)406	}407408	fn token_property(&self, token_id: TokenId, key: &PropertyKey) -> Option<PropertyValue> {409		<Pallet<T>>::token_properties((self.id, token_id))410			.get(key)411			.cloned()412	}413414	fn token_properties(&self, token_id: TokenId, keys: Option<Vec<PropertyKey>>) -> Vec<Property> {415		let properties = <Pallet<T>>::token_properties((self.id, token_id));416417		keys.map(|keys| {418			keys.into_iter()419				.filter_map(|key| {420					properties.get(&key).map(|value| Property {421						key,422						value: value.clone(),423					})424				})425				.collect()426		})427		.unwrap_or_else(|| {428			properties429				.into_iter()430				.map(|(key, value)| Property { key, value })431				.collect()432		})433	}434435	fn total_supply(&self) -> u32 {436		<Pallet<T>>::total_supply(self)437	}438439	fn account_balance(&self, account: T::CrossAccountId) -> u32 {440		<AccountBalance<T>>::get((self.id, account))441	}442443	fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128 {444		if <TokenData<T>>::get((self.id, token))445			.map(|a| a.owner == account)446			.unwrap_or(false)447		{448			1449		} else {450			0451		}452	}453454	fn allowance(455		&self,456		sender: T::CrossAccountId,457		spender: T::CrossAccountId,458		token: TokenId,459	) -> u128 {460		if <TokenData<T>>::get((self.id, token))461			.map(|a| a.owner != sender)462			.unwrap_or(true)463		{464			0465		} else if <Allowance<T>>::get((self.id, token)) == Some(spender) {466			1467		} else {468			0469		}470	}471472	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>> {473		None474	}475}