git.delta.rocks / unique-network / refs/commits / 14bb047eacd3

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 sp_std::collections::btree_map::BTreeMap;20use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight, traits::Get};21use up_data_structs::{22	CollectionId, TokenId, CreateItemExData, CreateRefungibleExData, budget::Budget, Property,23	PropertyKey, PropertyValue, PropertyKeyPermission, CreateItemData, CollectionPropertiesVec,24};25use pallet_common::{26	CommonCollectionOperations, CommonWeightInfo, RefungibleExtensions, with_weight,27	weights::WeightInfo as _,28};29use pallet_structure::Error as StructureError;30use sp_runtime::{DispatchError};31use sp_std::{vec::Vec, vec};3233use crate::{34	AccountBalance, Allowance, Balance, Config, Error, Owned, Pallet, RefungibleHandle,35	SelfWeightOf, TokenData, weights::WeightInfo, TokensMinted,36};3738macro_rules! max_weight_of {39	($($method:ident ($($args:tt)*)),*) => {40		041		$(42			.max(<SelfWeightOf<T>>::$method($($args)*))43		)*44	};45}4647fn properties_weight<T: Config>(properties: &CollectionPropertiesVec) -> u64 {48	if properties.len() > 0 {49		<CommonWeights<T>>::set_token_properties(properties.len() as u32)50	} else {51		052	}53}5455pub struct CommonWeights<T: Config>(PhantomData<T>);56impl<T: Config> CommonWeightInfo<T::CrossAccountId> for CommonWeights<T> {57	fn create_item() -> Weight {58		<SelfWeightOf<T>>::create_item()59	}6061	fn create_multiple_items(data: &[CreateItemData]) -> Weight {62		<SelfWeightOf<T>>::create_multiple_items(data.len() as u32).saturating_add(63			data.iter()64				.map(|data| match data {65					CreateItemData::ReFungible(rft_data) => {66						properties_weight::<T>(&rft_data.properties)67					}68					_ => 0,69				})70				.fold(0, |a, b| a.saturating_add(b)),71		)72	}7374	fn create_multiple_items_ex(call: &CreateItemExData<T::CrossAccountId>) -> Weight {75		match call {76			CreateItemExData::RefungibleMultipleOwners(i) => {77				<SelfWeightOf<T>>::create_multiple_items_ex_multiple_owners(i.users.len() as u32)78					.saturating_add(properties_weight::<T>(&i.properties))79			}80			CreateItemExData::RefungibleMultipleItems(i) => {81				<SelfWeightOf<T>>::create_multiple_items_ex_multiple_items(i.len() as u32)82					.saturating_add(83						i.iter()84							.map(|d| properties_weight::<T>(&d.properties))85							.fold(0, |a, b| a.saturating_add(b)),86					)87			}88			_ => 0,89		}90	}9192	fn burn_item() -> Weight {93		max_weight_of!(burn_item_partial(), burn_item_fully())94	}9596	fn set_collection_properties(amount: u32) -> Weight {97		<pallet_common::SelfWeightOf<T>>::set_collection_properties(amount)98	}99100	fn delete_collection_properties(amount: u32) -> Weight {101		<pallet_common::SelfWeightOf<T>>::delete_collection_properties(amount)102	}103104	fn set_token_properties(amount: u32) -> Weight {105		<SelfWeightOf<T>>::set_token_properties(amount)106	}107108	fn delete_token_properties(amount: u32) -> Weight {109		<SelfWeightOf<T>>::delete_token_properties(amount)110	}111112	fn set_token_property_permissions(amount: u32) -> Weight {113		<SelfWeightOf<T>>::set_token_property_permissions(amount)114	}115116	fn transfer() -> Weight {117		max_weight_of!(118			transfer_normal(),119			transfer_creating(),120			transfer_removing(),121			transfer_creating_removing()122		)123	}124125	fn approve() -> Weight {126		<SelfWeightOf<T>>::approve()127	}128129	fn transfer_from() -> Weight {130		max_weight_of!(131			transfer_from_normal(),132			transfer_from_creating(),133			transfer_from_removing(),134			transfer_from_creating_removing()135		)136	}137138	fn burn_from() -> Weight {139		<SelfWeightOf<T>>::burn_from()140	}141142	fn burn_recursively_self_raw() -> Weight {143		// Read to get total balance144		Self::burn_item() + T::DbWeight::get().reads(1)145	}146	fn burn_recursively_breadth_raw(_amount: u32) -> Weight {147		// Refungible token can't have children148		0149	}150}151152fn map_create_data<T: Config>(153	data: up_data_structs::CreateItemData,154	to: &T::CrossAccountId,155) -> Result<CreateRefungibleExData<T::CrossAccountId>, DispatchError> {156	match data {157		up_data_structs::CreateItemData::ReFungible(data) => Ok(CreateRefungibleExData {158			const_data: data.const_data,159			users: {160				let mut out = BTreeMap::new();161				out.insert(to.clone(), data.pieces);162				out.try_into().expect("limit > 0")163			},164			properties: data.properties,165		}),166		_ => fail!(<Error<T>>::NotRefungibleDataUsedToMintFungibleCollectionToken),167	}168}169170/// Implementation of `CommonCollectionOperations` for `RefungibleHandle`. It wraps Refungible Pallete171/// methods and adds weight info.172impl<T: Config> CommonCollectionOperations<T> for RefungibleHandle<T> {173	fn create_item(174		&self,175		sender: T::CrossAccountId,176		to: T::CrossAccountId,177		data: up_data_structs::CreateItemData,178		nesting_budget: &dyn Budget,179	) -> DispatchResultWithPostInfo {180		with_weight(181			<Pallet<T>>::create_item(182				self,183				&sender,184				map_create_data::<T>(data, &to)?,185				nesting_budget,186			),187			<CommonWeights<T>>::create_item(),188		)189	}190191	fn create_multiple_items(192		&self,193		sender: T::CrossAccountId,194		to: T::CrossAccountId,195		data: Vec<up_data_structs::CreateItemData>,196		nesting_budget: &dyn Budget,197	) -> DispatchResultWithPostInfo {198		let weight = <CommonWeights<T>>::create_multiple_items(&data);199		let data = data200			.into_iter()201			.map(|d| map_create_data::<T>(d, &to))202			.collect::<Result<Vec<_>, DispatchError>>()?;203204		with_weight(205			<Pallet<T>>::create_multiple_items(self, &sender, data, nesting_budget),206			weight,207		)208	}209210	fn create_multiple_items_ex(211		&self,212		sender: <T>::CrossAccountId,213		data: CreateItemExData<T::CrossAccountId>,214		nesting_budget: &dyn Budget,215	) -> DispatchResultWithPostInfo {216		let weight = <CommonWeights<T>>::create_multiple_items_ex(&data);217		let data = match data {218			CreateItemExData::RefungibleMultipleOwners(r) => vec![r],219			CreateItemExData::RefungibleMultipleItems(r)220				if r.iter().all(|i| i.users.len() == 1) =>221			{222				r.into_inner()223			}224			_ => fail!(<Error<T>>::NotRefungibleDataUsedToMintFungibleCollectionToken),225		};226227		with_weight(228			<Pallet<T>>::create_multiple_items(self, &sender, data, nesting_budget),229			weight,230		)231	}232233	fn burn_item(234		&self,235		sender: T::CrossAccountId,236		token: TokenId,237		amount: u128,238	) -> DispatchResultWithPostInfo {239		with_weight(240			<Pallet<T>>::burn(self, &sender, token, amount),241			<CommonWeights<T>>::burn_item(),242		)243	}244245	fn burn_item_recursively(246		&self,247		sender: T::CrossAccountId,248		token: TokenId,249		self_budget: &dyn Budget,250		_breadth_budget: &dyn Budget,251	) -> DispatchResultWithPostInfo {252		ensure!(self_budget.consume(), <StructureError<T>>::DepthLimit,);253		with_weight(254			<Pallet<T>>::burn(255				self,256				&sender,257				token,258				<Balance<T>>::get((self.id, token, &sender)),259			),260			<CommonWeights<T>>::burn_recursively_self_raw(),261		)262	}263264	fn transfer(265		&self,266		from: T::CrossAccountId,267		to: T::CrossAccountId,268		token: TokenId,269		amount: u128,270		nesting_budget: &dyn Budget,271	) -> DispatchResultWithPostInfo {272		with_weight(273			<Pallet<T>>::transfer(self, &from, &to, token, amount, nesting_budget),274			<CommonWeights<T>>::transfer(),275		)276	}277278	fn approve(279		&self,280		sender: T::CrossAccountId,281		spender: T::CrossAccountId,282		token: TokenId,283		amount: u128,284	) -> DispatchResultWithPostInfo {285		with_weight(286			<Pallet<T>>::set_allowance(self, &sender, &spender, token, amount),287			<CommonWeights<T>>::approve(),288		)289	}290291	fn transfer_from(292		&self,293		sender: T::CrossAccountId,294		from: T::CrossAccountId,295		to: T::CrossAccountId,296		token: TokenId,297		amount: u128,298		nesting_budget: &dyn Budget,299	) -> DispatchResultWithPostInfo {300		with_weight(301			<Pallet<T>>::transfer_from(self, &sender, &from, &to, token, amount, nesting_budget),302			<CommonWeights<T>>::transfer_from(),303		)304	}305306	fn burn_from(307		&self,308		sender: T::CrossAccountId,309		from: T::CrossAccountId,310		token: TokenId,311		amount: u128,312		nesting_budget: &dyn Budget,313	) -> DispatchResultWithPostInfo {314		with_weight(315			<Pallet<T>>::burn_from(self, &sender, &from, token, amount, nesting_budget),316			<CommonWeights<T>>::burn_from(),317		)318	}319320	fn set_collection_properties(321		&self,322		sender: T::CrossAccountId,323		properties: Vec<Property>,324	) -> DispatchResultWithPostInfo {325		let weight = <CommonWeights<T>>::set_collection_properties(properties.len() as u32);326327		with_weight(328			<Pallet<T>>::set_collection_properties(self, &sender, properties),329			weight,330		)331	}332333	fn delete_collection_properties(334		&self,335		sender: &T::CrossAccountId,336		property_keys: Vec<PropertyKey>,337	) -> DispatchResultWithPostInfo {338		let weight = <CommonWeights<T>>::delete_collection_properties(property_keys.len() as u32);339340		with_weight(341			<Pallet<T>>::delete_collection_properties(self, sender, property_keys),342			weight,343		)344	}345346	fn set_token_properties(347		&self,348		sender: T::CrossAccountId,349		token_id: TokenId,350		properties: Vec<Property>,351		nesting_budget: &dyn Budget,352	) -> DispatchResultWithPostInfo {353		let weight = <CommonWeights<T>>::set_token_properties(properties.len() as u32);354355		with_weight(356			<Pallet<T>>::set_token_properties(357				self,358				&sender,359				token_id,360				properties.into_iter(),361				false,362				nesting_budget,363			),364			weight,365		)366	}367368	fn set_token_property_permissions(369		&self,370		sender: &T::CrossAccountId,371		property_permissions: Vec<PropertyKeyPermission>,372	) -> DispatchResultWithPostInfo {373		let weight =374			<CommonWeights<T>>::set_token_property_permissions(property_permissions.len() as u32);375376		with_weight(377			<Pallet<T>>::set_token_property_permissions(self, sender, property_permissions),378			weight,379		)380	}381382	fn delete_token_properties(383		&self,384		sender: T::CrossAccountId,385		token_id: TokenId,386		property_keys: Vec<PropertyKey>,387		nesting_budget: &dyn Budget,388	) -> DispatchResultWithPostInfo {389		let weight = <CommonWeights<T>>::delete_token_properties(property_keys.len() as u32);390391		with_weight(392			<Pallet<T>>::delete_token_properties(393				self,394				&sender,395				token_id,396				property_keys.into_iter(),397				nesting_budget,398			),399			weight,400		)401	}402403	fn check_nesting(404		&self,405		_sender: <T>::CrossAccountId,406		_from: (CollectionId, TokenId),407		_under: TokenId,408		_nesting_budget: &dyn Budget,409	) -> sp_runtime::DispatchResult {410		fail!(<Error<T>>::RefungibleDisallowsNesting)411	}412413	fn nest(&self, _under: TokenId, _to_nest: (CollectionId, TokenId)) {}414415	fn unnest(&self, _under: TokenId, _to_nest: (CollectionId, TokenId)) {}416417	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId> {418		<Owned<T>>::iter_prefix((self.id, account))419			.map(|(id, _)| id)420			.collect()421	}422423	fn collection_tokens(&self) -> Vec<TokenId> {424		<TokenData<T>>::iter_prefix((self.id,))425			.map(|(id, _)| id)426			.collect()427	}428429	fn token_exists(&self, token: TokenId) -> bool {430		<Pallet<T>>::token_exists(self, token)431	}432433	fn last_token_id(&self) -> TokenId {434		TokenId(<TokensMinted<T>>::get(self.id))435	}436437	fn token_owner(&self, token: TokenId) -> Option<T::CrossAccountId> {438		<Pallet<T>>::token_owner(self.id, token)439	}440441	fn token_property(&self, _token_id: TokenId, _key: &PropertyKey) -> Option<PropertyValue> {442		None443	}444445	fn token_properties(446		&self,447		_token_id: TokenId,448		_keys: Option<Vec<PropertyKey>>,449	) -> Vec<Property> {450		Vec::new()451	}452453	fn total_supply(&self) -> u32 {454		<Pallet<T>>::total_supply(self)455	}456457	fn account_balance(&self, account: T::CrossAccountId) -> u32 {458		<AccountBalance<T>>::get((self.id, account))459	}460461	fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128 {462		<Balance<T>>::get((self.id, token, account))463	}464465	fn allowance(466		&self,467		sender: T::CrossAccountId,468		spender: T::CrossAccountId,469		token: TokenId,470	) -> u128 {471		<Allowance<T>>::get((self.id, token, sender, spender))472	}473474	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>> {475		Some(self)476	}477478	fn total_pieces(&self, token: TokenId) -> Option<u128> {479		<Pallet<T>>::total_pieces(self.id, token)480	}481}482483impl<T: Config> RefungibleExtensions<T> for RefungibleHandle<T> {484	fn repartition(485		&self,486		owner: &T::CrossAccountId,487		token: TokenId,488		amount: u128,489	) -> DispatchResultWithPostInfo {490		with_weight(491			<Pallet<T>>::repartition(self, owner, token, amount),492			<SelfWeightOf<T>>::repartition_item(),493		)494	}495}