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

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/>.1617//! # Refungible Pallet18//!19//! The Refungible pallet provides functionality for handling refungible collections and tokens.20//!21//! - [`Config`]22//! - [`RefungibleHandle`]23//! - [`Pallet`]24//! - [`CommonWeights`](common::CommonWeights)25//!26//! ## Overview27//!28//! The Refungible pallet provides functions for:29//!30//! - RFT collection creation and removal31//! - Minting and burning of RFT tokens32//! - Partition and repartition of RFT tokens33//! - Retrieving number of pieces of RFT token34//! - Retrieving account balances35//! - Transfering RFT token pieces36//! - Burning RFT token pieces37//! - Setting and checking allowance for RFT tokens38//!39//! ### Terminology40//!41//! - **RFT token:** Non fungible token that was partitioned to pieces. If an account owns all42//!   of the RFT token pieces than it owns the RFT token and can repartition it.43//!44//! - **RFT Collection:** A collection of RFT tokens. All RFT tokens are part of a collection.45//!   Each collection has its own settings and set of permissions.46//!47//! - **RFT token piece:** A fungible part of an RFT token.48//!49//! - **Balance:** RFT token pieces owned by an account50//!51//! - **Allowance:** Maximum number of RFT token pieces that one account is allowed to52//!   transfer from the balance of another account53//!54//! - **Burning:** The process of “deleting” a token from a collection or removing token pieces from55//!   an account balance.56//!57//! ### Implementations58//!59//! The Refungible pallet provides implementations for the following traits. If these traits provide60//! the functionality that you need, then you can avoid coupling with the Refungible pallet.61//!62//! - [`CommonWeightInfo`](pallet_common::CommonWeightInfo): Functions for retrieval of transaction weight63//! - [`CommonCollectionOperations`](pallet_common::CommonCollectionOperations): Functions for dealing64//!   with collections65//! - [`RefungibleExtensions`](pallet_common::RefungibleExtensions): Functions specific for refungible66//!   collection67//!68//! ## Interface69//!70//! ### Dispatchable Functions71//!72//! - `init_collection` - Create RFT collection. RFT collection can be configured to allow or deny access for73//!   some accounts.74//! - `destroy_collection` - Destroy exising RFT collection. There should be no tokens in the collection.75//! - `burn` - Burn some amount of RFT token pieces owned by account. Burns the RFT token if no pieces left.76//! - `transfer` - Transfer some amount of RFT token pieces. Transfers should be enabled for RFT collection.77//!   Nests the RFT token if RFT token pieces are sent to another token.78//! - `create_item` - Mint RFT token in collection. Sender should have permission to mint tokens.79//! - `set_allowance` - Set allowance for another account to transfer balance from sender's account.80//! - `repartition` - Repartition token to selected number of pieces. Sender should own all existing pieces.81//!82//! ## Assumptions83//!84//! * Total number of pieces for one token shouldn't exceed `up_data_structs::MAX_REFUNGIBLE_PIECES`.85//! * Total number of tokens of all types shouldn't be greater than `up_data_structs::MAX_TOKEN_PREFIX_LENGTH`.86//! * Sender should be in collection's allow list to perform operations on tokens.8788#![cfg_attr(not(feature = "std"), no_std)]8990use crate::erc_token::ERC20Events;91use crate::erc::ERC721Events;9293use codec::{Encode, Decode, MaxEncodedLen};94use core::ops::Deref;95use derivative::Derivative;96use evm_coder::ToLog;97use frame_support::{98	BoundedBTreeMap, BoundedVec, ensure, fail, storage::with_transaction, transactional,99	pallet_prelude::ConstU32,100};101use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};102use pallet_evm_coder_substrate::WithRecorder;103use pallet_common::{104	CommonCollectionOperations, Error as CommonError, eth::collection_id_to_address,105	Event as CommonEvent, Pallet as PalletCommon,106};107use pallet_structure::Pallet as PalletStructure;108use scale_info::TypeInfo;109use sp_core::H160;110use sp_runtime::{ArithmeticError, DispatchError, DispatchResult, TransactionOutcome};111use sp_std::{vec::Vec, vec, collections::btree_map::BTreeMap};112use up_data_structs::{113	AccessMode, budget::Budget, CollectionId, CollectionFlags, CollectionPropertiesVec,114	CreateCollectionData, CustomDataLimit, mapping::TokenAddressMapping, MAX_ITEMS_PER_BATCH,115	MAX_REFUNGIBLE_PIECES, Property, PropertyKey, PropertyKeyPermission, PropertyPermission,116	PropertyScope, PropertyValue, TokenId, TrySetProperty,117};118119pub use pallet::*;120#[cfg(feature = "runtime-benchmarks")]121pub mod benchmarking;122pub mod common;123pub mod erc;124pub mod erc_token;125pub mod weights;126127#[derive(Derivative, Clone)]128pub struct CreateItemData<CrossAccountId> {129	#[derivative(Debug(format_with = "bounded::map_debug"))]130	pub users: BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,131	#[derivative(Debug(format_with = "bounded::vec_debug"))]132	pub properties: CollectionPropertiesVec,133}134pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;135136/// Token data, stored independently from other data used to describe it137/// for the convenience of database access. Notably contains the token metadata.138#[struct_versioning::versioned(version = 2, upper)]139#[derive(Encode, Decode, Default, TypeInfo, MaxEncodedLen)]140pub struct ItemData {141	pub const_data: BoundedVec<u8, CustomDataLimit>,142143	#[version(..2)]144	pub variable_data: BoundedVec<u8, CustomDataLimit>,145}146147#[frame_support::pallet]148pub mod pallet {149	use super::*;150	use frame_support::{151		Blake2_128, Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key,152		traits::StorageVersion,153	};154	use frame_system::pallet_prelude::*;155	use up_data_structs::{CollectionId, TokenId};156	use super::weights::WeightInfo;157158	#[pallet::error]159	pub enum Error<T> {160		/// Not Refungible item data used to mint in Refungible collection.161		NotRefungibleDataUsedToMintFungibleCollectionToken,162		/// Maximum refungibility exceeded.163		WrongRefungiblePieces,164		/// Refungible token can't be repartitioned by user who isn't owns all pieces.165		RepartitionWhileNotOwningAllPieces,166		/// Refungible token can't nest other tokens.167		RefungibleDisallowsNesting,168		/// Setting item properties is not allowed.169		SettingPropertiesNotAllowed,170	}171172	#[pallet::config]173	pub trait Config:174		frame_system::Config + pallet_common::Config + pallet_structure::Config175	{176		type WeightInfo: WeightInfo;177	}178179	const STORAGE_VERSION: StorageVersion = StorageVersion::new(2);180181	#[pallet::pallet]182	#[pallet::storage_version(STORAGE_VERSION)]183	#[pallet::generate_store(pub(super) trait Store)]184	pub struct Pallet<T>(_);185186	/// Total amount of minted tokens in a collection.187	#[pallet::storage]188	pub type TokensMinted<T: Config> =189		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;190191	/// Amount of tokens burnt in a collection.192	#[pallet::storage]193	pub type TokensBurnt<T: Config> =194		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;195196	/// Token data, used to partially describe a token.197	// TODO: remove198	#[pallet::storage]199	#[deprecated(since = "0.2.0", note = "ItemData is no more contains usefull data")]200	pub type TokenData<T: Config> = StorageNMap<201		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),202		Value = ItemData,203		QueryKind = ValueQuery,204	>;205206	/// Amount of pieces a refungible token is split into.207	#[pallet::storage]208	#[pallet::getter(fn token_properties)]209	pub type TokenProperties<T: Config> = StorageNMap<210		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),211		Value = up_data_structs::Properties,212		QueryKind = ValueQuery,213		OnEmpty = up_data_structs::TokenProperties,214	>;215216	/// Total amount of pieces for token217	#[pallet::storage]218	pub type TotalSupply<T: Config> = StorageNMap<219		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),220		Value = u128,221		QueryKind = ValueQuery,222	>;223224	/// Used to enumerate tokens owned by account.225	#[pallet::storage]226	pub type Owned<T: Config> = StorageNMap<227		Key = (228			Key<Twox64Concat, CollectionId>,229			Key<Blake2_128Concat, T::CrossAccountId>,230			Key<Twox64Concat, TokenId>,231		),232		Value = bool,233		QueryKind = ValueQuery,234	>;235236	/// Amount of tokens (not pieces) partially owned by an account within a collection.237	#[pallet::storage]238	pub type AccountBalance<T: Config> = StorageNMap<239		Key = (240			Key<Twox64Concat, CollectionId>,241			// Owner242			Key<Blake2_128Concat, T::CrossAccountId>,243		),244		Value = u32,245		QueryKind = ValueQuery,246	>;247248	/// Amount of token pieces owned by account.249	#[pallet::storage]250	pub type Balance<T: Config> = StorageNMap<251		Key = (252			Key<Twox64Concat, CollectionId>,253			Key<Twox64Concat, TokenId>,254			// Owner255			Key<Blake2_128Concat, T::CrossAccountId>,256		),257		Value = u128,258		QueryKind = ValueQuery,259	>;260261	/// Allowance set by a token owner for another user to perform one of certain transactions on a number of pieces of a token.262	#[pallet::storage]263	pub type Allowance<T: Config> = StorageNMap<264		Key = (265			Key<Twox64Concat, CollectionId>,266			Key<Twox64Concat, TokenId>,267			// Owner268			Key<Blake2_128, T::CrossAccountId>,269			// Spender270			Key<Blake2_128Concat, T::CrossAccountId>,271		),272		Value = u128,273		QueryKind = ValueQuery,274	>;275276	#[pallet::hooks]277	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {278		fn on_runtime_upgrade() -> Weight {279			let storage_version = StorageVersion::get::<Pallet<T>>();280			if storage_version < StorageVersion::new(2) {281				#[allow(deprecated)]282				let _ = <TokenData<T>>::clear(u32::MAX, None);283			}284			StorageVersion::new(2).put::<Pallet<T>>();285286			Weight::zero()287		}288	}289}290291pub struct RefungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);292impl<T: Config> RefungibleHandle<T> {293	pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {294		Self(inner)295	}296	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {297		self.0298	}299	pub fn common_mut(&mut self) -> &mut pallet_common::CollectionHandle<T> {300		&mut self.0301	}302}303304impl<T: Config> Deref for RefungibleHandle<T> {305	type Target = pallet_common::CollectionHandle<T>;306307	fn deref(&self) -> &Self::Target {308		&self.0309	}310}311312impl<T: Config> WithRecorder<T> for RefungibleHandle<T> {313	fn recorder(&self) -> &pallet_evm_coder_substrate::SubstrateRecorder<T> {314		self.0.recorder()315	}316	fn into_recorder(self) -> pallet_evm_coder_substrate::SubstrateRecorder<T> {317		self.0.into_recorder()318	}319}320321impl<T: Config> Pallet<T> {322	/// Get number of RFT tokens in collection323	pub fn total_supply(collection: &RefungibleHandle<T>) -> u32 {324		<TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)325	}326327	/// Check that RFT token exists328	///329	/// - `token`: Token ID.330	pub fn token_exists(collection: &RefungibleHandle<T>, token: TokenId) -> bool {331		<TotalSupply<T>>::contains_key((collection.id, token))332	}333334	pub fn set_scoped_token_property(335		collection_id: CollectionId,336		token_id: TokenId,337		scope: PropertyScope,338		property: Property,339	) -> DispatchResult {340		TokenProperties::<T>::try_mutate((collection_id, token_id), |properties| {341			properties.try_scoped_set(scope, property.key, property.value)342		})343		.map_err(<CommonError<T>>::from)?;344345		Ok(())346	}347348	pub fn set_scoped_token_properties(349		collection_id: CollectionId,350		token_id: TokenId,351		scope: PropertyScope,352		properties: impl Iterator<Item = Property>,353	) -> DispatchResult {354		TokenProperties::<T>::try_mutate((collection_id, token_id), |stored_properties| {355			stored_properties.try_scoped_set_from_iter(scope, properties)356		})357		.map_err(<CommonError<T>>::from)?;358359		Ok(())360	}361}362363// unchecked calls skips any permission checks364impl<T: Config> Pallet<T> {365	/// Create RFT collection366	///367	/// `init_collection` will take non-refundable deposit for collection creation.368	///369	/// - `data`: Contains settings for collection limits and permissions.370	pub fn init_collection(371		owner: T::CrossAccountId,372		payer: T::CrossAccountId,373		data: CreateCollectionData<T::AccountId>,374		flags: CollectionFlags,375	) -> Result<CollectionId, DispatchError> {376		<PalletCommon<T>>::init_collection(owner, payer, data, flags)377	}378379	/// Destroy RFT collection380	///381	/// `destroy_collection` will throw error if collection contains any tokens.382	/// Only owner can destroy collection.383	pub fn destroy_collection(384		collection: RefungibleHandle<T>,385		sender: &T::CrossAccountId,386	) -> DispatchResult {387		let id = collection.id;388389		if Self::collection_has_tokens(id) {390			return Err(<CommonError<T>>::CantDestroyNotEmptyCollection.into());391		}392393		// =========394395		PalletCommon::destroy_collection(collection.0, sender)?;396397		<TokensMinted<T>>::remove(id);398		<TokensBurnt<T>>::remove(id);399		let _ = <TotalSupply<T>>::clear_prefix((id,), u32::MAX, None);400		let _ = <Balance<T>>::clear_prefix((id,), u32::MAX, None);401		let _ = <Allowance<T>>::clear_prefix((id,), u32::MAX, None);402		let _ = <Owned<T>>::clear_prefix((id,), u32::MAX, None);403		let _ = <AccountBalance<T>>::clear_prefix((id,), u32::MAX, None);404		Ok(())405	}406407	fn collection_has_tokens(collection_id: CollectionId) -> bool {408		<TotalSupply<T>>::iter_prefix((collection_id,))409			.next()410			.is_some()411	}412413	pub fn burn_token_unchecked(414		collection: &RefungibleHandle<T>,415		owner: &T::CrossAccountId,416		token_id: TokenId,417	) -> DispatchResult {418		let burnt = <TokensBurnt<T>>::get(collection.id)419			.checked_add(1)420			.ok_or(ArithmeticError::Overflow)?;421422		<TokensBurnt<T>>::insert(collection.id, burnt);423		<TokenProperties<T>>::remove((collection.id, token_id));424		<TotalSupply<T>>::remove((collection.id, token_id));425		let _ = <Balance<T>>::clear_prefix((collection.id, token_id), u32::MAX, None);426		let _ = <Allowance<T>>::clear_prefix((collection.id, token_id), u32::MAX, None);427		<PalletEvm<T>>::deposit_log(428			ERC721Events::Transfer {429				from: *owner.as_eth(),430				to: H160::default(),431				token_id: token_id.into(),432			}433			.to_log(collection_id_to_address(collection.id)),434		);435		Ok(())436	}437438	/// Burn RFT token pieces439	///440	/// `burn` will decrease total amount of token pieces and amount owned by sender.441	/// `burn` can be called even if there are multiple owners of the RFT token.442	/// If sender wouldn't have any pieces left after `burn` than she will stop being443	/// one of the owners of the token. If there is no account that owns any pieces of444	/// the token than token will be burned too.445	///446	/// - `amount`: Amount of token pieces to burn.447	/// - `token`: Token who's pieces should be burned448	/// - `collection`: Collection that contains the token449	pub fn burn(450		collection: &RefungibleHandle<T>,451		owner: &T::CrossAccountId,452		token: TokenId,453		amount: u128,454	) -> DispatchResult {455		if <Balance<T>>::get((collection.id, token, owner)) == 0 {456			return Err(<CommonError<T>>::TokenValueTooLow.into());457		}458459		let total_supply = <TotalSupply<T>>::get((collection.id, token))460			.checked_sub(amount)461			.ok_or(<CommonError<T>>::TokenValueTooLow)?;462463		// This was probally last owner of this token?464		if total_supply == 0 {465			// Ensure user actually owns this amount466			ensure!(467				<Balance<T>>::get((collection.id, token, owner)) == amount,468				<CommonError<T>>::TokenValueTooLow469			);470			let account_balance = <AccountBalance<T>>::get((collection.id, owner))471				.checked_sub(1)472				// Should not occur473				.ok_or(ArithmeticError::Underflow)?;474475			// =========476477			<Owned<T>>::remove((collection.id, owner, token));478			<PalletStructure<T>>::unnest_if_nested(owner, collection.id, token);479			<AccountBalance<T>>::insert((collection.id, owner), account_balance);480			Self::burn_token_unchecked(collection, owner, token)?;481			<PalletEvm<T>>::deposit_log(482				ERC20Events::Transfer {483					from: *owner.as_eth(),484					to: H160::default(),485					value: amount.into(),486				}487				.to_log(collection_id_to_address(collection.id)),488			);489			<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(490				collection.id,491				token,492				owner.clone(),493				amount,494			));495			return Ok(());496		}497498		let balance = <Balance<T>>::get((collection.id, token, owner))499			.checked_sub(amount)500			.ok_or(<CommonError<T>>::TokenValueTooLow)?;501		let account_balance = if balance == 0 {502			<AccountBalance<T>>::get((collection.id, owner))503				.checked_sub(1)504				// Should not occur505				.ok_or(ArithmeticError::Underflow)?506		} else {507			0508		};509510		// =========511512		if balance == 0 {513			<Owned<T>>::remove((collection.id, owner, token));514			<PalletStructure<T>>::unnest_if_nested(owner, collection.id, token);515			<Balance<T>>::remove((collection.id, token, owner));516			<AccountBalance<T>>::insert((collection.id, owner), account_balance);517518			if let Some(user) = Self::token_owner(collection.id, token) {519				<PalletEvm<T>>::deposit_log(520					ERC721Events::Transfer {521						from: erc::ADDRESS_FOR_PARTIALLY_OWNED_TOKENS,522						to: *user.as_eth(),523						token_id: token.into(),524					}525					.to_log(collection_id_to_address(collection.id)),526				);527			}528		} else {529			<Balance<T>>::insert((collection.id, token, owner), balance);530		}531		<TotalSupply<T>>::insert((collection.id, token), total_supply);532533		<PalletEvm<T>>::deposit_log(534			ERC20Events::Transfer {535				from: *owner.as_eth(),536				to: H160::default(),537				value: amount.into(),538			}539			.to_log(T::EvmTokenAddressMapping::token_to_address(540				collection.id,541				token,542			)),543		);544		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(545			collection.id,546			token,547			owner.clone(),548			amount,549		));550		Ok(())551	}552553	#[transactional]554	fn modify_token_properties(555		collection: &RefungibleHandle<T>,556		sender: &T::CrossAccountId,557		token_id: TokenId,558		properties: impl Iterator<Item = (PropertyKey, Option<PropertyValue>)>,559		is_token_create: bool,560		nesting_budget: &dyn Budget,561	) -> DispatchResult {562		let is_collection_admin = || collection.is_owner_or_admin(sender);563		let is_token_owner = || -> Result<bool, DispatchError> {564			let balance = collection.balance(sender.clone(), token_id);565			let total_pieces: u128 =566				Self::total_pieces(collection.id, token_id).unwrap_or(u128::MAX);567			if balance != total_pieces {568				return Ok(false);569			}570571			let is_bundle_owner = <PalletStructure<T>>::check_indirectly_owned(572				sender.clone(),573				collection.id,574				token_id,575				None,576				nesting_budget,577			)?;578579			Ok(is_bundle_owner)580		};581582		for (key, value) in properties {583			let permission = <PalletCommon<T>>::property_permissions(collection.id)584				.get(&key)585				.cloned()586				.unwrap_or_else(PropertyPermission::none);587588			let is_property_exists = TokenProperties::<T>::get((collection.id, token_id))589				.get(&key)590				.is_some();591592			match permission {593				PropertyPermission { mutable: false, .. } if is_property_exists => {594					return Err(<CommonError<T>>::NoPermission.into());595				}596597				PropertyPermission {598					collection_admin,599					token_owner,600					..601				} => {602					//TODO: investigate threats during public minting.603					let is_token_create =604						is_token_create && (collection_admin || token_owner) && value.is_some();605					if !(is_token_create606						|| (collection_admin && is_collection_admin())607						|| (token_owner && is_token_owner()?))608					{609						fail!(<CommonError<T>>::NoPermission);610					}611				}612			}613614			match value {615				Some(value) => {616					<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {617						properties.try_set(key.clone(), value)618					})619					.map_err(<CommonError<T>>::from)?;620621					<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertySet(622						collection.id,623						token_id,624						key,625					));626				}627				None => {628					<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {629						properties.remove(&key)630					})631					.map_err(<CommonError<T>>::from)?;632633					<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertyDeleted(634						collection.id,635						token_id,636						key,637					));638				}639			}640		}641642		Ok(())643	}644645	pub fn set_token_properties(646		collection: &RefungibleHandle<T>,647		sender: &T::CrossAccountId,648		token_id: TokenId,649		properties: impl Iterator<Item = Property>,650		is_token_create: bool,651		nesting_budget: &dyn Budget,652	) -> DispatchResult {653		Self::modify_token_properties(654			collection,655			sender,656			token_id,657			properties.map(|p| (p.key, Some(p.value))),658			is_token_create,659			nesting_budget,660		)661	}662663	pub fn set_token_property(664		collection: &RefungibleHandle<T>,665		sender: &T::CrossAccountId,666		token_id: TokenId,667		property: Property,668		nesting_budget: &dyn Budget,669	) -> DispatchResult {670		let is_token_create = false;671672		Self::set_token_properties(673			collection,674			sender,675			token_id,676			[property].into_iter(),677			is_token_create,678			nesting_budget,679		)680	}681682	pub fn delete_token_properties(683		collection: &RefungibleHandle<T>,684		sender: &T::CrossAccountId,685		token_id: TokenId,686		property_keys: impl Iterator<Item = PropertyKey>,687		nesting_budget: &dyn Budget,688	) -> DispatchResult {689		let is_token_create = false;690691		Self::modify_token_properties(692			collection,693			sender,694			token_id,695			property_keys.into_iter().map(|key| (key, None)),696			is_token_create,697			nesting_budget,698		)699	}700701	pub fn delete_token_property(702		collection: &RefungibleHandle<T>,703		sender: &T::CrossAccountId,704		token_id: TokenId,705		property_key: PropertyKey,706		nesting_budget: &dyn Budget,707	) -> DispatchResult {708		Self::delete_token_properties(709			collection,710			sender,711			token_id,712			[property_key].into_iter(),713			nesting_budget,714		)715	}716717	/// Transfer RFT token pieces from one account to another.718	///719	/// If the sender is no longer owns any pieces after the `transfer` than she stops being an owner of the token.720	///721	/// - `from`: Owner of token pieces to transfer.722	/// - `to`: Recepient of transfered token pieces.723	/// - `amount`: Amount of token pieces to transfer.724	/// - `token`: Token whos pieces should be transfered725	/// - `collection`: Collection that contains the token726	pub fn transfer(727		collection: &RefungibleHandle<T>,728		from: &T::CrossAccountId,729		to: &T::CrossAccountId,730		token: TokenId,731		amount: u128,732		nesting_budget: &dyn Budget,733	) -> DispatchResult {734		ensure!(735			collection.limits.transfers_enabled(),736			<CommonError<T>>::TransferNotAllowed737		);738739		if collection.permissions.access() == AccessMode::AllowList {740			collection.check_allowlist(from)?;741			collection.check_allowlist(to)?;742		}743		<PalletCommon<T>>::ensure_correct_receiver(to)?;744745		let initial_balance_from = <Balance<T>>::get((collection.id, token, from));746747		if initial_balance_from == 0 {748			return Err(<CommonError<T>>::TokenValueTooLow.into());749		}750751		let updated_balance_from = initial_balance_from752			.checked_sub(amount)753			.ok_or(<CommonError<T>>::TokenValueTooLow)?;754		let mut create_target = false;755		let from_to_differ = from != to;756		let updated_balance_to = if from != to && amount != 0 {757			let old_balance = <Balance<T>>::get((collection.id, token, to));758			if old_balance == 0 {759				create_target = true;760			}761			Some(762				old_balance763					.checked_add(amount)764					.ok_or(ArithmeticError::Overflow)?,765			)766		} else {767			None768		};769770		let account_balance_from = if updated_balance_from == 0 {771			Some(772				<AccountBalance<T>>::get((collection.id, from))773					.checked_sub(1)774					// Should not occur775					.ok_or(ArithmeticError::Underflow)?,776			)777		} else {778			None779		};780		// Account data is created in token, AccountBalance should be increased781		// But only if from != to as we shouldn't check overflow in this case782		let account_balance_to = if create_target && from_to_differ {783			let account_balance_to = <AccountBalance<T>>::get((collection.id, to))784				.checked_add(1)785				.ok_or(ArithmeticError::Overflow)?;786			ensure!(787				account_balance_to < collection.limits.account_token_ownership_limit(),788				<CommonError<T>>::AccountTokenLimitExceeded,789			);790791			Some(account_balance_to)792		} else {793			None794		};795796		// =========797798		if let Some(updated_balance_to) = updated_balance_to {799			// from != to && amount != 0800801			<PalletStructure<T>>::nest_if_sent_to_token(802				from.clone(),803				to,804				collection.id,805				token,806				nesting_budget,807			)?;808809			if updated_balance_from == 0 {810				<Balance<T>>::remove((collection.id, token, from));811				<PalletStructure<T>>::unnest_if_nested(from, collection.id, token);812			} else {813				<Balance<T>>::insert((collection.id, token, from), updated_balance_from);814			}815			<Balance<T>>::insert((collection.id, token, to), updated_balance_to);816			if let Some(account_balance_from) = account_balance_from {817				<AccountBalance<T>>::insert((collection.id, from), account_balance_from);818				<Owned<T>>::remove((collection.id, from, token));819			}820			if let Some(account_balance_to) = account_balance_to {821				<AccountBalance<T>>::insert((collection.id, to), account_balance_to);822				<Owned<T>>::insert((collection.id, to, token), true);823			}824		}825826		<PalletEvm<T>>::deposit_log(827			ERC20Events::Transfer {828				from: *from.as_eth(),829				to: *to.as_eth(),830				value: amount.into(),831			}832			.to_log(T::EvmTokenAddressMapping::token_to_address(833				collection.id,834				token,835			)),836		);837838		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(839			collection.id,840			token,841			from.clone(),842			to.clone(),843			amount,844		));845846		let total_supply = <TotalSupply<T>>::get((collection.id, token));847848		if amount == total_supply {849			// if token was fully owned by `from` and will be fully owned by `to` after transfer850			<PalletEvm<T>>::deposit_log(851				ERC721Events::Transfer {852					from: *from.as_eth(),853					to: *to.as_eth(),854					token_id: token.into(),855				}856				.to_log(collection_id_to_address(collection.id)),857			);858		} else if let Some(updated_balance_to) = updated_balance_to {859			// if `from` not equals `to`. This condition is needed to avoid sending event860			// when `from` fully owns token and sends part of token pieces to itself.861			if initial_balance_from == total_supply {862				// if token was fully owned by `from` and will be only partially owned by `to`863				// and `from` after transfer864				<PalletEvm<T>>::deposit_log(865					ERC721Events::Transfer {866						from: *from.as_eth(),867						to: erc::ADDRESS_FOR_PARTIALLY_OWNED_TOKENS,868						token_id: token.into(),869					}870					.to_log(collection_id_to_address(collection.id)),871				);872			} else if updated_balance_to == total_supply {873				// if token was partially owned by `from` and will be fully owned by `to` after transfer874				<PalletEvm<T>>::deposit_log(875					ERC721Events::Transfer {876						from: erc::ADDRESS_FOR_PARTIALLY_OWNED_TOKENS,877						to: *to.as_eth(),878						token_id: token.into(),879					}880					.to_log(collection_id_to_address(collection.id)),881				);882			}883		}884885		Ok(())886	}887888	/// Batched operation to create multiple RFT tokens.889	///890	/// Same as `create_item` but creates multiple tokens.891	///892	/// - `data`: Same as 'data` in `create_item` but contains data for multiple tokens.893	pub fn create_multiple_items(894		collection: &RefungibleHandle<T>,895		sender: &T::CrossAccountId,896		data: Vec<CreateItemData<T::CrossAccountId>>,897		nesting_budget: &dyn Budget,898	) -> DispatchResult {899		if !collection.is_owner_or_admin(sender) {900			ensure!(901				collection.permissions.mint_mode(),902				<CommonError<T>>::PublicMintingNotAllowed903			);904			collection.check_allowlist(sender)?;905906			for item in data.iter() {907				for user in item.users.keys() {908					collection.check_allowlist(user)?;909				}910			}911		}912913		for item in data.iter() {914			for (owner, _) in item.users.iter() {915				<PalletCommon<T>>::ensure_correct_receiver(owner)?;916			}917		}918919		// Total pieces per tokens920		let totals = data921			.iter()922			.map(|data| {923				Ok(data924					.users925					.iter()926					.map(|u| u.1)927					.try_fold(0u128, |acc, v| acc.checked_add(*v))928					.ok_or(ArithmeticError::Overflow)?)929			})930			.collect::<Result<Vec<_>, DispatchError>>()?;931		for total in &totals {932			ensure!(933				*total <= MAX_REFUNGIBLE_PIECES,934				<Error<T>>::WrongRefungiblePieces935			);936		}937938		let first_token_id = <TokensMinted<T>>::get(collection.id);939		let tokens_minted = first_token_id940			.checked_add(data.len() as u32)941			.ok_or(ArithmeticError::Overflow)?;942		ensure!(943			tokens_minted < collection.limits.token_limit(),944			<CommonError<T>>::CollectionTokenLimitExceeded945		);946947		let mut balances = BTreeMap::new();948		for data in &data {949			for owner in data.users.keys() {950				let balance = balances951					.entry(owner)952					.or_insert_with(|| <AccountBalance<T>>::get((collection.id, owner)));953				*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;954955				ensure!(956					*balance <= collection.limits.account_token_ownership_limit(),957					<CommonError<T>>::AccountTokenLimitExceeded,958				);959			}960		}961962		for (i, token) in data.iter().enumerate() {963			let token_id = TokenId(first_token_id + i as u32 + 1);964			for (to, _) in token.users.iter() {965				<PalletStructure<T>>::check_nesting(966					sender.clone(),967					to,968					collection.id,969					token_id,970					nesting_budget,971				)?;972			}973		}974975		// =========976977		with_transaction(|| {978			for (i, data) in data.iter().enumerate() {979				let token_id = first_token_id + i as u32 + 1;980				<TotalSupply<T>>::insert((collection.id, token_id), totals[i]);981982				for (user, amount) in data.users.iter() {983					if *amount == 0 {984						continue;985					}986					<Balance<T>>::insert((collection.id, token_id, &user), amount);987					<Owned<T>>::insert((collection.id, &user, TokenId(token_id)), true);988					<PalletStructure<T>>::nest_if_sent_to_token_unchecked(989						user,990						collection.id,991						TokenId(token_id),992					);993				}994995				if let Err(e) = Self::set_token_properties(996					collection,997					sender,998					TokenId(token_id),999					data.properties.clone().into_iter(),1000					true,1001					nesting_budget,1002				) {1003					return TransactionOutcome::Rollback(Err(e));1004				}1005			}1006			TransactionOutcome::Commit(Ok(()))1007		})?;10081009		<TokensMinted<T>>::insert(collection.id, tokens_minted);10101011		for (account, balance) in balances {1012			<AccountBalance<T>>::insert((collection.id, account), balance);1013		}10141015		for (i, token) in data.into_iter().enumerate() {1016			let token_id = first_token_id + i as u32 + 1;10171018			let receivers = token1019				.users1020				.into_iter()1021				.filter(|(_, amount)| *amount > 0)1022				.collect::<Vec<_>>();10231024			if let [(user, _)] = receivers.as_slice() {1025				// if there is exactly one receiver1026				<PalletEvm<T>>::deposit_log(1027					ERC721Events::Transfer {1028						from: H160::default(),1029						to: *user.as_eth(),1030						token_id: token_id.into(),1031					}1032					.to_log(collection_id_to_address(collection.id)),1033				);1034			} else if let [_, ..] = receivers.as_slice() {1035				// if there is more than one receiver1036				<PalletEvm<T>>::deposit_log(1037					ERC721Events::Transfer {1038						from: H160::default(),1039						to: erc::ADDRESS_FOR_PARTIALLY_OWNED_TOKENS,1040						token_id: token_id.into(),1041					}1042					.to_log(collection_id_to_address(collection.id)),1043				);1044			}10451046			for (user, amount) in receivers.into_iter() {1047				<PalletEvm<T>>::deposit_log(1048					ERC20Events::Transfer {1049						from: H160::default(),1050						to: *user.as_eth(),1051						value: amount.into(),1052					}1053					.to_log(T::EvmTokenAddressMapping::token_to_address(1054						collection.id,1055						TokenId(token_id),1056					)),1057				);1058				<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(1059					collection.id,1060					TokenId(token_id),1061					user,1062					amount,1063				));1064			}1065		}1066		Ok(())1067	}10681069	pub fn set_allowance_unchecked(1070		collection: &RefungibleHandle<T>,1071		sender: &T::CrossAccountId,1072		spender: &T::CrossAccountId,1073		token: TokenId,1074		amount: u128,1075	) {1076		if amount == 0 {1077			<Allowance<T>>::remove((collection.id, token, sender, spender));1078		} else {1079			<Allowance<T>>::insert((collection.id, token, sender, spender), amount);1080		}10811082		<PalletEvm<T>>::deposit_log(1083			ERC20Events::Approval {1084				owner: *sender.as_eth(),1085				spender: *spender.as_eth(),1086				value: amount.into(),1087			}1088			.to_log(T::EvmTokenAddressMapping::token_to_address(1089				collection.id,1090				token,1091			)),1092		);1093		<PalletCommon<T>>::deposit_event(CommonEvent::Approved(1094			collection.id,1095			token,1096			sender.clone(),1097			spender.clone(),1098			amount,1099		))1100	}11011102	/// Set allowance for the spender to `transfer` or `burn` sender's token pieces.1103	///1104	/// - `amount`: Amount of token pieces the spender is allowed to `transfer` or `burn.1105	pub fn set_allowance(1106		collection: &RefungibleHandle<T>,1107		sender: &T::CrossAccountId,1108		spender: &T::CrossAccountId,1109		token: TokenId,1110		amount: u128,1111	) -> DispatchResult {1112		if collection.permissions.access() == AccessMode::AllowList {1113			collection.check_allowlist(sender)?;1114			collection.check_allowlist(spender)?;1115		}11161117		<PalletCommon<T>>::ensure_correct_receiver(spender)?;11181119		if <Balance<T>>::get((collection.id, token, sender)) < amount {1120			ensure!(1121				collection.ignores_owned_amount(sender) && Self::token_exists(collection, token),1122				<CommonError<T>>::CantApproveMoreThanOwned1123			);1124		}11251126		// =========11271128		Self::set_allowance_unchecked(collection, sender, spender, token, amount);1129		Ok(())1130	}11311132	/// Returns allowance, which should be set after transaction1133	fn check_allowed(1134		collection: &RefungibleHandle<T>,1135		spender: &T::CrossAccountId,1136		from: &T::CrossAccountId,1137		token: TokenId,1138		amount: u128,1139		nesting_budget: &dyn Budget,1140	) -> Result<Option<u128>, DispatchError> {1141		if spender.conv_eq(from) {1142			return Ok(None);1143		}1144		if collection.permissions.access() == AccessMode::AllowList {1145			// `from`, `to` checked in [`transfer`]1146			collection.check_allowlist(spender)?;1147		}1148		if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {1149			// TODO: should collection owner be allowed to perform this transfer?1150			ensure!(1151				<PalletStructure<T>>::check_indirectly_owned(1152					spender.clone(),1153					source.0,1154					source.1,1155					None,1156					nesting_budget1157				)?,1158				<CommonError<T>>::ApprovedValueTooLow,1159			);1160			return Ok(None);1161		}1162		let allowance =1163			<Allowance<T>>::get((collection.id, token, from, &spender)).checked_sub(amount);1164		if allowance.is_none() {1165			ensure!(1166				collection.ignores_allowance(spender),1167				<CommonError<T>>::ApprovedValueTooLow1168			);1169		}1170		Ok(allowance)1171	}11721173	/// Transfer RFT token pieces from one account to another.1174	///1175	/// Same as the [`transfer`] but spender doesn't needs to be an owner of the token pieces.1176	/// The owner should set allowance for the spender to transfer pieces.1177	///1178	/// [`transfer`]: struct.Pallet.html#method.transfer1179	pub fn transfer_from(1180		collection: &RefungibleHandle<T>,1181		spender: &T::CrossAccountId,1182		from: &T::CrossAccountId,1183		to: &T::CrossAccountId,1184		token: TokenId,1185		amount: u128,1186		nesting_budget: &dyn Budget,1187	) -> DispatchResult {1188		let allowance =1189			Self::check_allowed(collection, spender, from, token, amount, nesting_budget)?;11901191		// =========11921193		Self::transfer(collection, from, to, token, amount, nesting_budget)?;1194		if let Some(allowance) = allowance {1195			Self::set_allowance_unchecked(collection, from, spender, token, allowance);1196		}1197		Ok(())1198	}11991200	/// Burn RFT token pieces from the account.1201	///1202	/// Same as the [`burn`] but spender doesn't need to be an owner of the token pieces. The owner should1203	/// set allowance for the spender to burn pieces1204	///1205	/// [`burn`]: struct.Pallet.html#method.burn1206	pub fn burn_from(1207		collection: &RefungibleHandle<T>,1208		spender: &T::CrossAccountId,1209		from: &T::CrossAccountId,1210		token: TokenId,1211		amount: u128,1212		nesting_budget: &dyn Budget,1213	) -> DispatchResult {1214		let allowance =1215			Self::check_allowed(collection, spender, from, token, amount, nesting_budget)?;12161217		// =========12181219		Self::burn(collection, from, token, amount)?;1220		if let Some(allowance) = allowance {1221			Self::set_allowance_unchecked(collection, from, spender, token, allowance);1222		}1223		Ok(())1224	}12251226	/// Create RFT token.1227	///1228	/// The sender should be the owner/admin of the collection or collection should be configured1229	/// to allow public minting.1230	///1231	/// - `data`: Contains list of users who will become the owners of the token pieces and amount1232	///   of token pieces they will receive.1233	pub fn create_item(1234		collection: &RefungibleHandle<T>,1235		sender: &T::CrossAccountId,1236		data: CreateItemData<T::CrossAccountId>,1237		nesting_budget: &dyn Budget,1238	) -> DispatchResult {1239		Self::create_multiple_items(collection, sender, vec![data], nesting_budget)1240	}12411242	/// Repartition RFT token.1243	///1244	/// `repartition` will set token balance of the sender and total amount of token pieces.1245	/// Sender should own all of the token pieces. `repartition' could be done even if some1246	/// token pieces were burned before.1247	///1248	/// - `amount`: Total amount of token pieces that the token will have after `repartition`.1249	pub fn repartition(1250		collection: &RefungibleHandle<T>,1251		owner: &T::CrossAccountId,1252		token: TokenId,1253		amount: u128,1254	) -> DispatchResult {1255		ensure!(1256			amount <= MAX_REFUNGIBLE_PIECES,1257			<Error<T>>::WrongRefungiblePieces1258		);1259		ensure!(amount > 0, <CommonError<T>>::TokenValueTooLow);1260		// Ensure user owns all pieces1261		let total_pieces = Self::total_pieces(collection.id, token).unwrap_or(u128::MAX);1262		let balance = <Balance<T>>::get((collection.id, token, owner));1263		ensure!(1264			total_pieces == balance,1265			<Error<T>>::RepartitionWhileNotOwningAllPieces1266		);12671268		<Balance<T>>::insert((collection.id, token, owner), amount);1269		<TotalSupply<T>>::insert((collection.id, token), amount);12701271		if amount > total_pieces {1272			let mint_amount = amount - total_pieces;1273			<PalletEvm<T>>::deposit_log(1274				ERC20Events::Transfer {1275					from: H160::default(),1276					to: *owner.as_eth(),1277					value: mint_amount.into(),1278				}1279				.to_log(T::EvmTokenAddressMapping::token_to_address(1280					collection.id,1281					token,1282				)),1283			);1284			<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(1285				collection.id,1286				token,1287				owner.clone(),1288				mint_amount,1289			));1290		} else if total_pieces > amount {1291			let burn_amount = total_pieces - amount;1292			<PalletEvm<T>>::deposit_log(1293				ERC20Events::Transfer {1294					from: *owner.as_eth(),1295					to: H160::default(),1296					value: burn_amount.into(),1297				}1298				.to_log(T::EvmTokenAddressMapping::token_to_address(1299					collection.id,1300					token,1301				)),1302			);1303			<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(1304				collection.id,1305				token,1306				owner.clone(),1307				burn_amount,1308			));1309		}13101311		Ok(())1312	}13131314	fn token_owner(collection_id: CollectionId, token_id: TokenId) -> Option<T::CrossAccountId> {1315		let mut owner = None;1316		let mut count = 0;1317		for key in Balance::<T>::iter_key_prefix((collection_id, token_id)) {1318			count += 1;1319			if count > 1 {1320				return None;1321			}1322			owner = Some(key);1323		}1324		owner1325	}13261327	fn total_pieces(collection_id: CollectionId, token_id: TokenId) -> Option<u128> {1328		<TotalSupply<T>>::try_get((collection_id, token_id)).ok()1329	}13301331	pub fn set_collection_properties(1332		collection: &RefungibleHandle<T>,1333		sender: &T::CrossAccountId,1334		properties: Vec<Property>,1335	) -> DispatchResult {1336		<PalletCommon<T>>::set_collection_properties(collection, sender, properties)1337	}13381339	pub fn delete_collection_properties(1340		collection: &RefungibleHandle<T>,1341		sender: &T::CrossAccountId,1342		property_keys: Vec<PropertyKey>,1343	) -> DispatchResult {1344		<PalletCommon<T>>::delete_collection_properties(collection, sender, property_keys)1345	}13461347	pub fn set_token_property_permissions(1348		collection: &RefungibleHandle<T>,1349		sender: &T::CrossAccountId,1350		property_permissions: Vec<PropertyKeyPermission>,1351	) -> DispatchResult {1352		<PalletCommon<T>>::set_token_property_permissions(collection, sender, property_permissions)1353	}13541355	pub fn set_scoped_token_property_permissions(1356		collection: &RefungibleHandle<T>,1357		sender: &T::CrossAccountId,1358		scope: PropertyScope,1359		property_permissions: Vec<PropertyKeyPermission>,1360	) -> DispatchResult {1361		<PalletCommon<T>>::set_scoped_token_property_permissions(1362			collection,1363			sender,1364			scope,1365			property_permissions,1366		)1367	}13681369	/// Returns 10 token in no particular order.1370	///1371	/// There is no direct way to get token holders in ascending order,1372	/// since `iter_prefix` returns values in no particular order.1373	/// Therefore, getting the 10 largest holders with a large value of holders1374	/// can lead to impact memory allocation + sorting with  `n * log (n)`.1375	pub fn token_owners(1376		collection_id: CollectionId,1377		token: TokenId,1378	) -> Option<Vec<T::CrossAccountId>> {1379		let res: Vec<T::CrossAccountId> = <Balance<T>>::iter_prefix((collection_id, token))1380			.map(|(owner, _amount)| owner)1381			.take(10)1382			.collect();13831384		if res.is_empty() {1385			None1386		} else {1387			Some(res)1388		}1389	}1390}