git.delta.rocks / unique-network / refs/commits / 2abdf7d34dd3

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, budget::Budget, Property, PropertyKey, PropertyValue,23	PropertyKeyPermission, CollectionPropertiesVec, CreateRefungibleExMultipleOwners,24	CreateRefungibleExSingleOwner,25};26use pallet_common::{27	CommonCollectionOperations, CommonWeightInfo, RefungibleExtensions, with_weight,28	weights::WeightInfo as _,29};30use pallet_structure::Error as StructureError;31use sp_runtime::{DispatchError};32use sp_std::{vec::Vec, vec};3334use crate::{35	AccountBalance, Allowance, Balance, Config, Error, Owned, Pallet, RefungibleHandle,36	SelfWeightOf, weights::WeightInfo, TokensMinted, TotalSupply, CreateItemData,37};3839macro_rules! max_weight_of {40	($($method:ident ($($args:tt)*)),*) => {41		Weight::zero()42		$(43			.max(<SelfWeightOf<T>>::$method($($args)*))44		)*45	};46}4748fn properties_weight<T: Config>(properties: &CollectionPropertiesVec) -> Weight {49	if properties.len() > 0 {50		<CommonWeights<T>>::set_token_properties(properties.len() as u32)51	} else {52		Weight::zero()53	}54}5556pub struct CommonWeights<T: Config>(PhantomData<T>);57impl<T: Config> CommonWeightInfo<T::CrossAccountId> for CommonWeights<T> {58	fn create_item() -> Weight {59		<SelfWeightOf<T>>::create_item()60	}6162	fn create_multiple_items(data: &[up_data_structs::CreateItemData]) -> Weight {63		<SelfWeightOf<T>>::create_multiple_items(data.len() as u32).saturating_add(64			data.iter()65				.map(|data| match data {66					up_data_structs::CreateItemData::ReFungible(rft_data) => {67						properties_weight::<T>(&rft_data.properties)68					}69					_ => Weight::zero(),70				})71				.fold(Weight::zero(), |a, b| a.saturating_add(b)),72		)73	}7475	fn create_multiple_items_ex(call: &CreateItemExData<T::CrossAccountId>) -> Weight {76		match call {77			CreateItemExData::RefungibleMultipleOwners(i) => {78				<SelfWeightOf<T>>::create_multiple_items_ex_multiple_owners(i.users.len() as u32)79					.saturating_add(properties_weight::<T>(&i.properties))80			}81			CreateItemExData::RefungibleMultipleItems(i) => {82				<SelfWeightOf<T>>::create_multiple_items_ex_multiple_items(i.len() as u32)83					.saturating_add(84						i.iter()85							.map(|d| properties_weight::<T>(&d.properties))86							.fold(Weight::zero(), |a, b| a.saturating_add(b)),87					)88			}89			_ => Weight::zero(),90		}91	}9293	fn burn_item() -> Weight {94		max_weight_of!(burn_item_partial(), burn_item_fully())95	}9697	fn set_collection_properties(amount: u32) -> Weight {98		<pallet_common::SelfWeightOf<T>>::set_collection_properties(amount)99	}100101	fn delete_collection_properties(amount: u32) -> Weight {102		<pallet_common::SelfWeightOf<T>>::delete_collection_properties(amount)103	}104105	fn set_token_properties(amount: u32) -> Weight {106		<SelfWeightOf<T>>::set_token_properties(amount)107	}108109	fn delete_token_properties(amount: u32) -> Weight {110		<SelfWeightOf<T>>::delete_token_properties(amount)111	}112113	fn set_token_property_permissions(amount: u32) -> Weight {114		<SelfWeightOf<T>>::set_token_property_permissions(amount)115	}116117	fn transfer() -> Weight {118		max_weight_of!(119			transfer_normal(),120			transfer_creating(),121			transfer_removing(),122			transfer_creating_removing()123		)124	}125126	fn approve() -> Weight {127		<SelfWeightOf<T>>::approve()128	}129130	fn transfer_from() -> Weight {131		max_weight_of!(132			transfer_from_normal(),133			transfer_from_creating(),134			transfer_from_removing(),135			transfer_from_creating_removing()136		)137	}138139	fn burn_from() -> Weight {140		<SelfWeightOf<T>>::burn_from()141	}142143	fn burn_recursively_self_raw() -> Weight {144		// Read to get total balance145		Self::burn_item() + T::DbWeight::get().reads(1)146	}147	fn burn_recursively_breadth_raw(_amount: u32) -> Weight {148		// Refungible token can't have children149		Weight::zero()150	}151152	fn token_owner() -> Weight {153		<SelfWeightOf<T>>::token_owner()154	}155156	fn set_allowance_for_all() -> Weight {157		<SelfWeightOf<T>>::set_allowance_for_all()158	}159160	fn force_repair_item() -> Weight {161		<SelfWeightOf<T>>::repair_item()162	}163}164165fn map_create_data<T: Config>(166	data: up_data_structs::CreateItemData,167	to: &T::CrossAccountId,168) -> Result<CreateItemData<T>, DispatchError> {169	match data {170		up_data_structs::CreateItemData::ReFungible(data) => Ok(CreateItemData::<T> {171			users: {172				let mut out = BTreeMap::new();173				out.insert(to.clone(), data.pieces);174				out.try_into().expect("limit > 0")175			},176			properties: data.properties,177		}),178		_ => fail!(<Error<T>>::NotRefungibleDataUsedToMintFungibleCollectionToken),179	}180}181182/// Implementation of `CommonCollectionOperations` for `RefungibleHandle`. It wraps Refungible Pallete183/// methods and adds weight info.184impl<T: Config> CommonCollectionOperations<T> for RefungibleHandle<T> {185	fn create_item(186		&self,187		sender: T::CrossAccountId,188		to: T::CrossAccountId,189		data: up_data_structs::CreateItemData,190		nesting_budget: &dyn Budget,191	) -> DispatchResultWithPostInfo {192		with_weight(193			<Pallet<T>>::create_item(194				self,195				&sender,196				map_create_data::<T>(data, &to)?,197				nesting_budget,198			),199			<CommonWeights<T>>::create_item(),200		)201	}202203	fn create_multiple_items(204		&self,205		sender: T::CrossAccountId,206		to: T::CrossAccountId,207		data: Vec<up_data_structs::CreateItemData>,208		nesting_budget: &dyn Budget,209	) -> DispatchResultWithPostInfo {210		let weight = <CommonWeights<T>>::create_multiple_items(&data);211		let data = data212			.into_iter()213			.map(|d| map_create_data::<T>(d, &to))214			.collect::<Result<Vec<_>, DispatchError>>()?;215216		with_weight(217			<Pallet<T>>::create_multiple_items(self, &sender, data, nesting_budget),218			weight,219		)220	}221222	fn create_multiple_items_ex(223		&self,224		sender: <T>::CrossAccountId,225		data: CreateItemExData<T::CrossAccountId>,226		nesting_budget: &dyn Budget,227	) -> DispatchResultWithPostInfo {228		let weight = <CommonWeights<T>>::create_multiple_items_ex(&data);229		let data = match data {230			CreateItemExData::RefungibleMultipleOwners(CreateRefungibleExMultipleOwners {231				users,232				properties,233			}) => vec![CreateItemData::<T> { users, properties }],234			CreateItemExData::RefungibleMultipleItems(r) => r235				.into_inner()236				.into_iter()237				.map(238					|CreateRefungibleExSingleOwner {239					     user,240					     pieces,241					     properties,242					 }| CreateItemData::<T> {243						users: BTreeMap::from([(user, pieces)])244							.try_into()245							.expect("limit >= 1"),246						properties,247					},248				)249				.collect(),250			_ => fail!(<Error<T>>::NotRefungibleDataUsedToMintFungibleCollectionToken),251		};252253		with_weight(254			<Pallet<T>>::create_multiple_items(self, &sender, data, nesting_budget),255			weight,256		)257	}258259	fn burn_item(260		&self,261		sender: T::CrossAccountId,262		token: TokenId,263		amount: u128,264	) -> DispatchResultWithPostInfo {265		with_weight(266			<Pallet<T>>::burn(self, &sender, token, amount),267			<CommonWeights<T>>::burn_item(),268		)269	}270271	fn burn_item_recursively(272		&self,273		sender: T::CrossAccountId,274		token: TokenId,275		self_budget: &dyn Budget,276		_breadth_budget: &dyn Budget,277	) -> DispatchResultWithPostInfo {278		ensure!(self_budget.consume(), <StructureError<T>>::DepthLimit,);279		with_weight(280			<Pallet<T>>::burn(281				self,282				&sender,283				token,284				<Balance<T>>::get((self.id, token, &sender)),285			),286			<CommonWeights<T>>::burn_recursively_self_raw(),287		)288	}289290	fn transfer(291		&self,292		from: T::CrossAccountId,293		to: T::CrossAccountId,294		token: TokenId,295		amount: u128,296		nesting_budget: &dyn Budget,297	) -> DispatchResultWithPostInfo {298		with_weight(299			<Pallet<T>>::transfer(self, &from, &to, token, amount, nesting_budget),300			<CommonWeights<T>>::transfer(),301		)302	}303304	fn approve(305		&self,306		sender: T::CrossAccountId,307		spender: T::CrossAccountId,308		token: TokenId,309		amount: u128,310	) -> DispatchResultWithPostInfo {311		with_weight(312			<Pallet<T>>::set_allowance(self, &sender, &spender, token, amount),313			<CommonWeights<T>>::approve(),314		)315	}316317	fn transfer_from(318		&self,319		sender: T::CrossAccountId,320		from: T::CrossAccountId,321		to: T::CrossAccountId,322		token: TokenId,323		amount: u128,324		nesting_budget: &dyn Budget,325	) -> DispatchResultWithPostInfo {326		with_weight(327			<Pallet<T>>::transfer_from(self, &sender, &from, &to, token, amount, nesting_budget),328			<CommonWeights<T>>::transfer_from(),329		)330	}331332	fn burn_from(333		&self,334		sender: T::CrossAccountId,335		from: T::CrossAccountId,336		token: TokenId,337		amount: u128,338		nesting_budget: &dyn Budget,339	) -> DispatchResultWithPostInfo {340		with_weight(341			<Pallet<T>>::burn_from(self, &sender, &from, token, amount, nesting_budget),342			<CommonWeights<T>>::burn_from(),343		)344	}345346	fn set_collection_properties(347		&self,348		sender: T::CrossAccountId,349		properties: Vec<Property>,350	) -> DispatchResultWithPostInfo {351		let weight = <CommonWeights<T>>::set_collection_properties(properties.len() as u32);352353		with_weight(354			<Pallet<T>>::set_collection_properties(self, &sender, properties),355			weight,356		)357	}358359	fn delete_collection_properties(360		&self,361		sender: &T::CrossAccountId,362		property_keys: Vec<PropertyKey>,363	) -> DispatchResultWithPostInfo {364		let weight = <CommonWeights<T>>::delete_collection_properties(property_keys.len() as u32);365366		with_weight(367			<Pallet<T>>::delete_collection_properties(self, sender, property_keys),368			weight,369		)370	}371372	fn set_token_properties(373		&self,374		sender: T::CrossAccountId,375		token_id: TokenId,376		properties: Vec<Property>,377		nesting_budget: &dyn Budget,378	) -> DispatchResultWithPostInfo {379		let weight = <CommonWeights<T>>::set_token_properties(properties.len() as u32);380381		with_weight(382			<Pallet<T>>::set_token_properties(383				self,384				&sender,385				token_id,386				properties.into_iter(),387				false,388				nesting_budget,389			),390			weight,391		)392	}393394	fn set_token_property_permissions(395		&self,396		sender: &T::CrossAccountId,397		property_permissions: Vec<PropertyKeyPermission>,398	) -> DispatchResultWithPostInfo {399		let weight =400			<CommonWeights<T>>::set_token_property_permissions(property_permissions.len() as u32);401402		with_weight(403			<Pallet<T>>::set_token_property_permissions(self, sender, property_permissions),404			weight,405		)406	}407408	fn delete_token_properties(409		&self,410		sender: T::CrossAccountId,411		token_id: TokenId,412		property_keys: Vec<PropertyKey>,413		nesting_budget: &dyn Budget,414	) -> DispatchResultWithPostInfo {415		let weight = <CommonWeights<T>>::delete_token_properties(property_keys.len() as u32);416417		with_weight(418			<Pallet<T>>::delete_token_properties(419				self,420				&sender,421				token_id,422				property_keys.into_iter(),423				nesting_budget,424			),425			weight,426		)427	}428429	fn check_nesting(430		&self,431		_sender: <T>::CrossAccountId,432		_from: (CollectionId, TokenId),433		_under: TokenId,434		_nesting_budget: &dyn Budget,435	) -> sp_runtime::DispatchResult {436		fail!(<Error<T>>::RefungibleDisallowsNesting)437	}438439	fn nest(&self, _under: TokenId, _to_nest: (CollectionId, TokenId)) {}440441	fn unnest(&self, _under: TokenId, _to_nest: (CollectionId, TokenId)) {}442443	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId> {444		<Owned<T>>::iter_prefix((self.id, account))445			.map(|(id, _)| id)446			.collect()447	}448449	fn collection_tokens(&self) -> Vec<TokenId> {450		<TotalSupply<T>>::iter_prefix((self.id,))451			.map(|(id, _)| id)452			.collect()453	}454455	fn token_exists(&self, token: TokenId) -> bool {456		<Pallet<T>>::token_exists(self, token)457	}458459	fn last_token_id(&self) -> TokenId {460		TokenId(<TokensMinted<T>>::get(self.id))461	}462463	fn token_owner(&self, token: TokenId) -> Option<T::CrossAccountId> {464		<Pallet<T>>::token_owner(self.id, token)465	}466467	/// Returns 10 token in no particular order.468	fn token_owners(&self, token: TokenId) -> Vec<T::CrossAccountId> {469		<Pallet<T>>::token_owners(self.id, token).unwrap_or_default()470	}471472	fn token_property(&self, token_id: TokenId, key: &PropertyKey) -> Option<PropertyValue> {473		<Pallet<T>>::token_properties((self.id, token_id))474			.get(key)475			.cloned()476	}477478	fn token_properties(&self, token_id: TokenId, keys: Option<Vec<PropertyKey>>) -> Vec<Property> {479		let properties = <Pallet<T>>::token_properties((self.id, token_id));480481		keys.map(|keys| {482			keys.into_iter()483				.filter_map(|key| {484					properties.get(&key).map(|value| Property {485						key,486						value: value.clone(),487					})488				})489				.collect()490		})491		.unwrap_or_else(|| {492			properties493				.into_iter()494				.map(|(key, value)| Property { key, value })495				.collect()496		})497	}498499	fn total_supply(&self) -> u32 {500		<Pallet<T>>::total_supply(self)501	}502503	fn account_balance(&self, account: T::CrossAccountId) -> u32 {504		<AccountBalance<T>>::get((self.id, account))505	}506507	fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128 {508		<Balance<T>>::get((self.id, token, account))509	}510511	fn allowance(512		&self,513		sender: T::CrossAccountId,514		spender: T::CrossAccountId,515		token: TokenId,516	) -> u128 {517		<Allowance<T>>::get((self.id, token, sender, spender))518	}519520	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>> {521		Some(self)522	}523524	fn total_pieces(&self, token: TokenId) -> Option<u128> {525		<Pallet<T>>::total_pieces(self.id, token)526	}527528	fn set_allowance_for_all(529		&self,530		owner: T::CrossAccountId,531		operator: T::CrossAccountId,532		approve: bool,533	) -> DispatchResultWithPostInfo {534		with_weight(535			<Pallet<T>>::set_allowance_for_all(self, &owner, &operator, approve),536			<CommonWeights<T>>::set_allowance_for_all(),537		)538	}539540	fn allowance_for_all(&self, owner: T::CrossAccountId, operator: T::CrossAccountId) -> bool {541		<Pallet<T>>::allowance_for_all(self, &owner, &operator)542	}543544	fn repair_item(&self, token: TokenId) -> DispatchResultWithPostInfo {545		with_weight(546			<Pallet<T>>::repair_item(self, token),547			<CommonWeights<T>>::force_repair_item(),548		)549	}550}551552impl<T: Config> RefungibleExtensions<T> for RefungibleHandle<T> {553	fn repartition(554		&self,555		owner: &T::CrossAccountId,556		token: TokenId,557		amount: u128,558	) -> DispatchResultWithPostInfo {559		with_weight(560			<Pallet<T>>::repartition(self, owner, token, amount),561			<SelfWeightOf<T>>::repartition_item(),562		)563	}564}