git.delta.rocks / unique-network / refs/commits / 0427b9aac8a2

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,24};25use pallet_common::{CommonCollectionOperations, CommonWeightInfo, RefungibleExtensions, with_weight};26use pallet_structure::Error as StructureError;27use sp_runtime::{DispatchError};28use sp_std::{vec::Vec, vec};2930use crate::{31	AccountBalance, Allowance, Balance, Config, Error, Owned, Pallet, RefungibleHandle,32	SelfWeightOf, TokenData, weights::WeightInfo, TokensMinted,33};3435macro_rules! max_weight_of {36	($($method:ident ($($args:tt)*)),*) => {37		038		$(39			.max(<SelfWeightOf<T>>::$method($($args)*))40		)*41	};42}4344pub struct CommonWeights<T: Config>(PhantomData<T>);45impl<T: Config> CommonWeightInfo<T::CrossAccountId> for CommonWeights<T> {46	fn create_item() -> Weight {47		<SelfWeightOf<T>>::create_item()48	}4950	fn create_multiple_items(data: &[CreateItemData]) -> Weight {51		<SelfWeightOf<T>>::create_multiple_items(data.len() as u32)52	}5354	fn create_multiple_items_ex(call: &CreateItemExData<T::CrossAccountId>) -> Weight {55		match call {56			CreateItemExData::RefungibleMultipleOwners(i) => {57				<SelfWeightOf<T>>::create_multiple_items_ex_multiple_owners(i.users.len() as u32)58			}59			CreateItemExData::RefungibleMultipleItems(i) => {60				<SelfWeightOf<T>>::create_multiple_items_ex_multiple_items(i.len() as u32)61			}62			_ => 0,63		}64	}6566	fn burn_item() -> Weight {67		max_weight_of!(burn_item_partial(), burn_item_fully())68	}6970	fn set_collection_properties(_amount: u32) -> Weight {71		// Error72		073	}7475	fn delete_collection_properties(_amount: u32) -> Weight {76		// Error77		078	}7980	fn set_token_properties(_amount: u32) -> Weight {81		// Error82		083	}8485	fn delete_token_properties(_amount: u32) -> Weight {86		// Error87		088	}8990	fn set_token_property_permissions(_amount: u32) -> Weight {91		// Error92		093	}9495	fn transfer() -> Weight {96		max_weight_of!(97			transfer_normal(),98			transfer_creating(),99			transfer_removing(),100			transfer_creating_removing()101		)102	}103104	fn approve() -> Weight {105		<SelfWeightOf<T>>::approve()106	}107108	fn transfer_from() -> Weight {109		max_weight_of!(110			transfer_from_normal(),111			transfer_from_creating(),112			transfer_from_removing(),113			transfer_from_creating_removing()114		)115	}116117	fn burn_from() -> Weight {118		<SelfWeightOf<T>>::burn_from()119	}120121	fn burn_recursively_self_raw() -> Weight {122		// Read to get total balance123		Self::burn_item() + T::DbWeight::get().reads(1)124	}125	fn burn_recursively_breadth_raw(_amount: u32) -> Weight {126		// Refungible token can't have children127		0128	}129}130131fn map_create_data<T: Config>(132	data: up_data_structs::CreateItemData,133	to: &T::CrossAccountId,134) -> Result<CreateRefungibleExData<T::CrossAccountId>, DispatchError> {135	match data {136		up_data_structs::CreateItemData::ReFungible(data) => Ok(CreateRefungibleExData {137			const_data: data.const_data,138			users: {139				let mut out = BTreeMap::new();140				out.insert(to.clone(), data.pieces);141				out.try_into().expect("limit > 0")142			},143			properties: data.properties,144		}),145		_ => fail!(<Error<T>>::NotRefungibleDataUsedToMintFungibleCollectionToken),146	}147}148149/// Implementation of `CommonCollectionOperations` for `RefungibleHandle`. It wraps Refungible Pallete150/// methods and adds weight info.151impl<T: Config> CommonCollectionOperations<T> for RefungibleHandle<T> {152	fn create_item(153		&self,154		sender: T::CrossAccountId,155		to: T::CrossAccountId,156		data: up_data_structs::CreateItemData,157		nesting_budget: &dyn Budget,158	) -> DispatchResultWithPostInfo {159		with_weight(160			<Pallet<T>>::create_item(161				self,162				&sender,163				map_create_data::<T>(data, &to)?,164				nesting_budget,165			),166			<CommonWeights<T>>::create_item(),167		)168	}169170	fn create_multiple_items(171		&self,172		sender: T::CrossAccountId,173		to: T::CrossAccountId,174		data: Vec<up_data_structs::CreateItemData>,175		nesting_budget: &dyn Budget,176	) -> DispatchResultWithPostInfo {177		let weight = <CommonWeights<T>>::create_multiple_items(&data);178		let data = data179			.into_iter()180			.map(|d| map_create_data::<T>(d, &to))181			.collect::<Result<Vec<_>, DispatchError>>()?;182183		with_weight(184			<Pallet<T>>::create_multiple_items(self, &sender, data, nesting_budget),185			weight,186		)187	}188189	fn create_multiple_items_ex(190		&self,191		sender: <T>::CrossAccountId,192		data: CreateItemExData<T::CrossAccountId>,193		nesting_budget: &dyn Budget,194	) -> DispatchResultWithPostInfo {195		let weight = <CommonWeights<T>>::create_multiple_items_ex(&data);196		let data = match data {197			CreateItemExData::RefungibleMultipleOwners(r) => vec![r],198			CreateItemExData::RefungibleMultipleItems(r)199				if r.iter().all(|i| i.users.len() == 1) =>200			{201				r.into_inner()202			}203			_ => fail!(<Error<T>>::NotRefungibleDataUsedToMintFungibleCollectionToken),204		};205206		with_weight(207			<Pallet<T>>::create_multiple_items(self, &sender, data, nesting_budget),208			weight,209		)210	}211212	fn burn_item(213		&self,214		sender: T::CrossAccountId,215		token: TokenId,216		amount: u128,217	) -> DispatchResultWithPostInfo {218		with_weight(219			<Pallet<T>>::burn(self, &sender, token, amount),220			<CommonWeights<T>>::burn_item(),221		)222	}223224	fn burn_item_recursively(225		&self,226		sender: T::CrossAccountId,227		token: TokenId,228		self_budget: &dyn Budget,229		_breadth_budget: &dyn Budget,230	) -> DispatchResultWithPostInfo {231		ensure!(self_budget.consume(), <StructureError<T>>::DepthLimit,);232		with_weight(233			<Pallet<T>>::burn(234				self,235				&sender,236				token,237				<Balance<T>>::get((self.id, token, &sender)),238			),239			<CommonWeights<T>>::burn_recursively_self_raw(),240		)241	}242243	fn transfer(244		&self,245		from: T::CrossAccountId,246		to: T::CrossAccountId,247		token: TokenId,248		amount: u128,249		nesting_budget: &dyn Budget,250	) -> DispatchResultWithPostInfo {251		with_weight(252			<Pallet<T>>::transfer(self, &from, &to, token, amount, nesting_budget),253			<CommonWeights<T>>::transfer(),254		)255	}256257	fn approve(258		&self,259		sender: T::CrossAccountId,260		spender: T::CrossAccountId,261		token: TokenId,262		amount: u128,263	) -> DispatchResultWithPostInfo {264		with_weight(265			<Pallet<T>>::set_allowance(self, &sender, &spender, token, amount),266			<CommonWeights<T>>::approve(),267		)268	}269270	fn transfer_from(271		&self,272		sender: T::CrossAccountId,273		from: T::CrossAccountId,274		to: T::CrossAccountId,275		token: TokenId,276		amount: u128,277		nesting_budget: &dyn Budget,278	) -> DispatchResultWithPostInfo {279		with_weight(280			<Pallet<T>>::transfer_from(self, &sender, &from, &to, token, amount, nesting_budget),281			<CommonWeights<T>>::transfer_from(),282		)283	}284285	fn burn_from(286		&self,287		sender: T::CrossAccountId,288		from: T::CrossAccountId,289		token: TokenId,290		amount: u128,291		nesting_budget: &dyn Budget,292	) -> DispatchResultWithPostInfo {293		with_weight(294			<Pallet<T>>::burn_from(self, &sender, &from, token, amount, nesting_budget),295			<CommonWeights<T>>::burn_from(),296		)297	}298299	fn set_collection_properties(300		&self,301		sender: T::CrossAccountId,302		properties: Vec<Property>,303	) -> DispatchResultWithPostInfo {304		let weight = <CommonWeights<T>>::set_collection_properties(properties.len() as u32);305306		with_weight(307			<Pallet<T>>::set_collection_properties(self, &sender, properties),308			weight,309		)310	}311312	fn delete_collection_properties(313		&self,314		sender: &T::CrossAccountId,315		property_keys: Vec<PropertyKey>,316	) -> DispatchResultWithPostInfo {317		let weight = <CommonWeights<T>>::delete_collection_properties(property_keys.len() as u32);318319		with_weight(320			<Pallet<T>>::delete_collection_properties(self, sender, property_keys),321			weight,322		)323	}324325	fn set_token_properties(326		&self,327		sender: T::CrossAccountId,328		token_id: TokenId,329		properties: Vec<Property>,330		nesting_budget: &dyn Budget,331	) -> DispatchResultWithPostInfo {332		let weight = <CommonWeights<T>>::set_token_properties(properties.len() as u32);333334		with_weight(335			<Pallet<T>>::set_token_properties(336				self,337				&sender,338				token_id,339				properties.into_iter(),340				false,341				nesting_budget,342			),343			weight,344		)345	}346347	fn set_token_property_permissions(348		&self,349		sender: &T::CrossAccountId,350		property_permissions: Vec<PropertyKeyPermission>,351	) -> DispatchResultWithPostInfo {352		let weight =353			<CommonWeights<T>>::set_token_property_permissions(property_permissions.len() as u32);354355		with_weight(356			<Pallet<T>>::set_token_property_permissions(self, sender, property_permissions),357			weight,358		)359	}360361	fn delete_token_properties(362		&self,363		sender: T::CrossAccountId,364		token_id: TokenId,365		property_keys: Vec<PropertyKey>,366		nesting_budget: &dyn Budget,367	) -> DispatchResultWithPostInfo {368		let weight = <CommonWeights<T>>::delete_token_properties(property_keys.len() as u32);369370		with_weight(371			<Pallet<T>>::delete_token_properties(372				self,373				&sender,374				token_id,375				property_keys.into_iter(),376				nesting_budget,377			),378			weight,379		)380	}381382	fn check_nesting(383		&self,384		_sender: <T>::CrossAccountId,385		_from: (CollectionId, TokenId),386		_under: TokenId,387		_nesting_budget: &dyn Budget,388	) -> sp_runtime::DispatchResult {389		fail!(<Error<T>>::RefungibleDisallowsNesting)390	}391392	fn nest(&self, _under: TokenId, _to_nest: (CollectionId, TokenId)) {}393394	fn unnest(&self, _under: TokenId, _to_nest: (CollectionId, TokenId)) {}395396	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId> {397		<Owned<T>>::iter_prefix((self.id, account))398			.map(|(id, _)| id)399			.collect()400	}401402	fn collection_tokens(&self) -> Vec<TokenId> {403		<TokenData<T>>::iter_prefix((self.id,))404			.map(|(id, _)| id)405			.collect()406	}407408	fn token_exists(&self, token: TokenId) -> bool {409		<Pallet<T>>::token_exists(self, token)410	}411412	fn last_token_id(&self) -> TokenId {413		TokenId(<TokensMinted<T>>::get(self.id))414	}415416	fn token_owner(&self, _token: TokenId) -> Option<T::CrossAccountId> {417		None418	}419420	fn token_property(&self, _token_id: TokenId, _key: &PropertyKey) -> Option<PropertyValue> {421		None422	}423424	fn token_properties(425		&self,426		_token_id: TokenId,427		_keys: Option<Vec<PropertyKey>>,428	) -> Vec<Property> {429		Vec::new()430	}431432	fn total_supply(&self) -> u32 {433		<Pallet<T>>::total_supply(self)434	}435436	fn account_balance(&self, account: T::CrossAccountId) -> u32 {437		<AccountBalance<T>>::get((self.id, account))438	}439440	fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128 {441		<Balance<T>>::get((self.id, token, account))442	}443444	fn allowance(445		&self,446		sender: T::CrossAccountId,447		spender: T::CrossAccountId,448		token: TokenId,449	) -> u128 {450		<Allowance<T>>::get((self.id, token, sender, spender))451	}452453	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>> {454		Some(self)455	}456457	fn total_pieces(&self, token: TokenId) -> Option<u128> {458		<Pallet<T>>::total_pieces(self.id, token)459	}460}461462impl<T: Config> RefungibleExtensions<T> for RefungibleHandle<T> {463	fn repartition(464		&self,465		owner: &T::CrossAccountId,466		token: TokenId,467		amount: u128,468	) -> DispatchResultWithPostInfo {469		with_weight(470			<Pallet<T>>::repartition(self, owner, token, amount),471			<SelfWeightOf<T>>::repartition_item(),472		)473	}474}