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

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	}159}160161fn map_create_data<T: Config>(162	data: up_data_structs::CreateItemData,163	to: &T::CrossAccountId,164) -> Result<CreateItemData<T::CrossAccountId>, DispatchError> {165	match data {166		up_data_structs::CreateItemData::ReFungible(data) => Ok(CreateItemData {167			users: {168				let mut out = BTreeMap::new();169				out.insert(to.clone(), data.pieces);170				out.try_into().expect("limit > 0")171			},172			properties: data.properties,173		}),174		_ => fail!(<Error<T>>::NotRefungibleDataUsedToMintFungibleCollectionToken),175	}176}177178/// Implementation of `CommonCollectionOperations` for `RefungibleHandle`. It wraps Refungible Pallete179/// methods and adds weight info.180impl<T: Config> CommonCollectionOperations<T> for RefungibleHandle<T> {181	fn create_item(182		&self,183		sender: T::CrossAccountId,184		to: T::CrossAccountId,185		data: up_data_structs::CreateItemData,186		nesting_budget: &dyn Budget,187	) -> DispatchResultWithPostInfo {188		with_weight(189			<Pallet<T>>::create_item(190				self,191				&sender,192				map_create_data::<T>(data, &to)?,193				nesting_budget,194			),195			<CommonWeights<T>>::create_item(),196		)197	}198199	fn create_multiple_items(200		&self,201		sender: T::CrossAccountId,202		to: T::CrossAccountId,203		data: Vec<up_data_structs::CreateItemData>,204		nesting_budget: &dyn Budget,205	) -> DispatchResultWithPostInfo {206		let weight = <CommonWeights<T>>::create_multiple_items(&data);207		let data = data208			.into_iter()209			.map(|d| map_create_data::<T>(d, &to))210			.collect::<Result<Vec<_>, DispatchError>>()?;211212		with_weight(213			<Pallet<T>>::create_multiple_items(self, &sender, data, nesting_budget),214			weight,215		)216	}217218	fn create_multiple_items_ex(219		&self,220		sender: <T>::CrossAccountId,221		data: CreateItemExData<T::CrossAccountId>,222		nesting_budget: &dyn Budget,223	) -> DispatchResultWithPostInfo {224		let weight = <CommonWeights<T>>::create_multiple_items_ex(&data);225		let data = match data {226			CreateItemExData::RefungibleMultipleOwners(CreateRefungibleExMultipleOwners {227				users,228				properties,229			}) => vec![CreateItemData { users, properties }],230			CreateItemExData::RefungibleMultipleItems(r) => r231				.into_inner()232				.into_iter()233				.map(234					|CreateRefungibleExSingleOwner {235					     user,236					     pieces,237					     properties,238					 }| CreateItemData {239						users: BTreeMap::from([(user, pieces)])240							.try_into()241							.expect("limit >= 1"),242						properties,243					},244				)245				.collect(),246			_ => fail!(<Error<T>>::NotRefungibleDataUsedToMintFungibleCollectionToken),247		};248249		with_weight(250			<Pallet<T>>::create_multiple_items(self, &sender, data, nesting_budget),251			weight,252		)253	}254255	fn burn_item(256		&self,257		sender: T::CrossAccountId,258		token: TokenId,259		amount: u128,260	) -> DispatchResultWithPostInfo {261		with_weight(262			<Pallet<T>>::burn(self, &sender, token, amount),263			<CommonWeights<T>>::burn_item(),264		)265	}266267	fn burn_item_recursively(268		&self,269		sender: T::CrossAccountId,270		token: TokenId,271		self_budget: &dyn Budget,272		_breadth_budget: &dyn Budget,273	) -> DispatchResultWithPostInfo {274		ensure!(self_budget.consume(), <StructureError<T>>::DepthLimit,);275		with_weight(276			<Pallet<T>>::burn(277				self,278				&sender,279				token,280				<Balance<T>>::get((self.id, token, &sender)),281			),282			<CommonWeights<T>>::burn_recursively_self_raw(),283		)284	}285286	fn transfer(287		&self,288		from: T::CrossAccountId,289		to: T::CrossAccountId,290		token: TokenId,291		amount: u128,292		nesting_budget: &dyn Budget,293	) -> DispatchResultWithPostInfo {294		with_weight(295			<Pallet<T>>::transfer(self, &from, &to, token, amount, nesting_budget),296			<CommonWeights<T>>::transfer(),297		)298	}299300	fn approve(301		&self,302		sender: T::CrossAccountId,303		spender: T::CrossAccountId,304		token: TokenId,305		amount: u128,306	) -> DispatchResultWithPostInfo {307		with_weight(308			<Pallet<T>>::set_allowance(self, &sender, &spender, token, amount),309			<CommonWeights<T>>::approve(),310		)311	}312313	fn transfer_from(314		&self,315		sender: T::CrossAccountId,316		from: T::CrossAccountId,317		to: T::CrossAccountId,318		token: TokenId,319		amount: u128,320		nesting_budget: &dyn Budget,321	) -> DispatchResultWithPostInfo {322		with_weight(323			<Pallet<T>>::transfer_from(self, &sender, &from, &to, token, amount, nesting_budget),324			<CommonWeights<T>>::transfer_from(),325		)326	}327328	fn burn_from(329		&self,330		sender: T::CrossAccountId,331		from: T::CrossAccountId,332		token: TokenId,333		amount: u128,334		nesting_budget: &dyn Budget,335	) -> DispatchResultWithPostInfo {336		with_weight(337			<Pallet<T>>::burn_from(self, &sender, &from, token, amount, nesting_budget),338			<CommonWeights<T>>::burn_from(),339		)340	}341342	fn set_collection_properties(343		&self,344		sender: T::CrossAccountId,345		properties: Vec<Property>,346	) -> DispatchResultWithPostInfo {347		let weight = <CommonWeights<T>>::set_collection_properties(properties.len() as u32);348349		with_weight(350			<Pallet<T>>::set_collection_properties(self, &sender, properties),351			weight,352		)353	}354355	fn delete_collection_properties(356		&self,357		sender: &T::CrossAccountId,358		property_keys: Vec<PropertyKey>,359	) -> DispatchResultWithPostInfo {360		let weight = <CommonWeights<T>>::delete_collection_properties(property_keys.len() as u32);361362		with_weight(363			<Pallet<T>>::delete_collection_properties(self, sender, property_keys),364			weight,365		)366	}367368	fn set_token_properties(369		&self,370		sender: T::CrossAccountId,371		token_id: TokenId,372		properties: Vec<Property>,373		nesting_budget: &dyn Budget,374	) -> DispatchResultWithPostInfo {375		let weight = <CommonWeights<T>>::set_token_properties(properties.len() as u32);376377		with_weight(378			<Pallet<T>>::set_token_properties(379				self,380				&sender,381				token_id,382				properties.into_iter(),383				false,384				nesting_budget,385			),386			weight,387		)388	}389390	fn set_token_property_permissions(391		&self,392		sender: &T::CrossAccountId,393		property_permissions: Vec<PropertyKeyPermission>,394	) -> DispatchResultWithPostInfo {395		let weight =396			<CommonWeights<T>>::set_token_property_permissions(property_permissions.len() as u32);397398		with_weight(399			<Pallet<T>>::set_token_property_permissions(self, sender, property_permissions),400			weight,401		)402	}403404	fn delete_token_properties(405		&self,406		sender: T::CrossAccountId,407		token_id: TokenId,408		property_keys: Vec<PropertyKey>,409		nesting_budget: &dyn Budget,410	) -> DispatchResultWithPostInfo {411		let weight = <CommonWeights<T>>::delete_token_properties(property_keys.len() as u32);412413		with_weight(414			<Pallet<T>>::delete_token_properties(415				self,416				&sender,417				token_id,418				property_keys.into_iter(),419				nesting_budget,420			),421			weight,422		)423	}424425	fn check_nesting(426		&self,427		_sender: <T>::CrossAccountId,428		_from: (CollectionId, TokenId),429		_under: TokenId,430		_nesting_budget: &dyn Budget,431	) -> sp_runtime::DispatchResult {432		fail!(<Error<T>>::RefungibleDisallowsNesting)433	}434435	fn nest(&self, _under: TokenId, _to_nest: (CollectionId, TokenId)) {}436437	fn unnest(&self, _under: TokenId, _to_nest: (CollectionId, TokenId)) {}438439	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId> {440		<Owned<T>>::iter_prefix((self.id, account))441			.map(|(id, _)| id)442			.collect()443	}444445	fn collection_tokens(&self) -> Vec<TokenId> {446		<TotalSupply<T>>::iter_prefix((self.id,))447			.map(|(id, _)| id)448			.collect()449	}450451	fn token_exists(&self, token: TokenId) -> bool {452		<Pallet<T>>::token_exists(self, token)453	}454455	fn last_token_id(&self) -> TokenId {456		TokenId(<TokensMinted<T>>::get(self.id))457	}458459	fn token_owner(&self, token: TokenId) -> Option<T::CrossAccountId> {460		<Pallet<T>>::token_owner(self.id, token)461	}462463	/// Returns 10 token in no particular order.464	fn token_owners(&self, token: TokenId) -> Vec<T::CrossAccountId> {465		<Pallet<T>>::token_owners(self.id, token).unwrap_or_default()466	}467468	fn token_property(&self, token_id: TokenId, key: &PropertyKey) -> Option<PropertyValue> {469		<Pallet<T>>::token_properties((self.id, token_id))470			.get(key)471			.cloned()472	}473474	fn token_properties(&self, token_id: TokenId, keys: Option<Vec<PropertyKey>>) -> Vec<Property> {475		let properties = <Pallet<T>>::token_properties((self.id, token_id));476477		keys.map(|keys| {478			keys.into_iter()479				.filter_map(|key| {480					properties.get(&key).map(|value| Property {481						key,482						value: value.clone(),483					})484				})485				.collect()486		})487		.unwrap_or_else(|| {488			properties489				.into_iter()490				.map(|(key, value)| Property { key, value })491				.collect()492		})493	}494495	fn total_supply(&self) -> u32 {496		<Pallet<T>>::total_supply(self)497	}498499	fn account_balance(&self, account: T::CrossAccountId) -> u32 {500		<AccountBalance<T>>::get((self.id, account))501	}502503	fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128 {504		<Balance<T>>::get((self.id, token, account))505	}506507	fn allowance(508		&self,509		sender: T::CrossAccountId,510		spender: T::CrossAccountId,511		token: TokenId,512	) -> u128 {513		<Allowance<T>>::get((self.id, token, sender, spender))514	}515516	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>> {517		Some(self)518	}519520	fn total_pieces(&self, token: TokenId) -> Option<u128> {521		<Pallet<T>>::total_pieces(self.id, token)522	}523524	fn set_allowance_for_all(525		&self,526		owner: T::CrossAccountId,527		operator: T::CrossAccountId,528		approve: bool,529	) -> DispatchResultWithPostInfo {530		with_weight(531			<Pallet<T>>::set_allowance_for_all(self, &owner, &operator, approve),532			<CommonWeights<T>>::set_allowance_for_all(),533		)534	}535536	fn allowance_for_all(&self, owner: T::CrossAccountId, operator: T::CrossAccountId) -> bool {537		<Pallet<T>>::allowance_for_all(self, &owner, &operator)538	}539}540541impl<T: Config> RefungibleExtensions<T> for RefungibleHandle<T> {542	fn repartition(543		&self,544		owner: &T::CrossAccountId,545		token: TokenId,546		amount: u128,547	) -> DispatchResultWithPostInfo {548		with_weight(549			<Pallet<T>>::repartition(self, owner, token, amount),550			<SelfWeightOf<T>>::repartition_item(),551		)552	}553}