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

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 evm_coder::ToLog;96use frame_support::{97	BoundedVec, ensure, fail, storage::with_transaction, transactional, pallet_prelude::ConstU32,98};99use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};100use pallet_evm_coder_substrate::WithRecorder;101use pallet_common::{102	CommonCollectionOperations,103	Error as CommonError,104	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,114	CollectionPropertiesVec, CreateCollectionData, CustomDataLimit, mapping::TokenAddressMapping,115	MAX_ITEMS_PER_BATCH, MAX_REFUNGIBLE_PIECES, Property, PropertyKey, PropertyKeyPermission,116	PropertyPermission, PropertyScope, PropertyValue, TokenId, TrySetProperty,117};118use frame_support::BoundedBTreeMap;119use derivative::Derivative;120121pub use pallet::*;122#[cfg(feature = "runtime-benchmarks")]123pub mod benchmarking;124pub mod common;125pub mod erc;126pub mod erc_token;127pub mod weights;128129#[derive(Derivative, Clone)]130pub struct CreateItemData<CrossAccountId> {131	#[derivative(Debug(format_with = "bounded::map_debug"))]132	pub users: BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,133	#[derivative(Debug(format_with = "bounded::vec_debug"))]134	pub properties: CollectionPropertiesVec,135}136pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;137138/// Token data, stored independently from other data used to describe it139/// for the convenience of database access. Notably contains the token metadata.140#[struct_versioning::versioned(version = 2, upper)]141#[derive(Encode, Decode, Default, TypeInfo, MaxEncodedLen)]142#[deprecated(since = "0.2.0", note = "ItemData is no more contains usefull data")]143pub struct ItemData {144	pub const_data: BoundedVec<u8, CustomDataLimit>,145146	#[version(..2)]147	pub variable_data: BoundedVec<u8, CustomDataLimit>,148}149150#[frame_support::pallet]151pub mod pallet {152	use super::*;153	use frame_support::{154		Blake2_128, Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key,155		traits::StorageVersion,156	};157	use frame_system::pallet_prelude::*;158	use up_data_structs::{CollectionId, TokenId};159	use super::weights::WeightInfo;160161	#[pallet::error]162	pub enum Error<T> {163		/// Not Refungible item data used to mint in Refungible collection.164		NotRefungibleDataUsedToMintFungibleCollectionToken,165		/// Maximum refungibility exceeded.166		WrongRefungiblePieces,167		/// Refungible token can't be repartitioned by user who isn't owns all pieces.168		RepartitionWhileNotOwningAllPieces,169		/// Refungible token can't nest other tokens.170		RefungibleDisallowsNesting,171		/// Setting item properties is not allowed.172		SettingPropertiesNotAllowed,173	}174175	#[pallet::config]176	pub trait Config:177		frame_system::Config + pallet_common::Config + pallet_structure::Config178	{179		type WeightInfo: WeightInfo;180	}181182	const STORAGE_VERSION: StorageVersion = StorageVersion::new(2);183184	#[pallet::pallet]185	#[pallet::storage_version(STORAGE_VERSION)]186	#[pallet::generate_store(pub(super) trait Store)]187	pub struct Pallet<T>(_);188189	/// Total amount of minted tokens in a collection.190	#[pallet::storage]191	pub type TokensMinted<T: Config> =192		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;193194	/// Amount of tokens burnt in a collection.195	#[pallet::storage]196	pub type TokensBurnt<T: Config> =197		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;198199	/// Token data, used to partially describe a token.200	// TODO: remove201	#[pallet::storage]202	#[deprecated(since = "0.2.0", note = "ItemData is no more contains usefull data")]203	pub type TokenData<T: Config> = StorageNMap<204		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),205		Value = ItemData,206		QueryKind = ValueQuery,207	>;208209	/// Amount of pieces a refungible token is split into.210	#[pallet::storage]211	#[pallet::getter(fn token_properties)]212	pub type TokenProperties<T: Config> = StorageNMap<213		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),214		Value = up_data_structs::Properties,215		QueryKind = ValueQuery,216		OnEmpty = up_data_structs::TokenProperties,217	>;218219	/// Total amount of pieces for token220	#[pallet::storage]221	pub type TotalSupply<T: Config> = StorageNMap<222		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),223		Value = u128,224		QueryKind = ValueQuery,225	>;226227	/// Used to enumerate tokens owned by account.228	#[pallet::storage]229	pub type Owned<T: Config> = StorageNMap<230		Key = (231			Key<Twox64Concat, CollectionId>,232			Key<Blake2_128Concat, T::CrossAccountId>,233			Key<Twox64Concat, TokenId>,234		),235		Value = bool,236		QueryKind = ValueQuery,237	>;238239	/// Amount of tokens (not pieces) partially owned by an account within a collection.240	#[pallet::storage]241	pub type AccountBalance<T: Config> = StorageNMap<242		Key = (243			Key<Twox64Concat, CollectionId>,244			// Owner245			Key<Blake2_128Concat, T::CrossAccountId>,246		),247		Value = u32,248		QueryKind = ValueQuery,249	>;250251	/// Amount of token pieces owned by account.252	#[pallet::storage]253	pub type Balance<T: Config> = StorageNMap<254		Key = (255			Key<Twox64Concat, CollectionId>,256			Key<Twox64Concat, TokenId>,257			// Owner258			Key<Blake2_128Concat, T::CrossAccountId>,259		),260		Value = u128,261		QueryKind = ValueQuery,262	>;263264	/// Allowance set by a token owner for another user to perform one of certain transactions on a number of pieces of a token.265	#[pallet::storage]266	pub type Allowance<T: Config> = StorageNMap<267		Key = (268			Key<Twox64Concat, CollectionId>,269			Key<Twox64Concat, TokenId>,270			// Owner271			Key<Blake2_128, T::CrossAccountId>,272			// Spender273			Key<Blake2_128Concat, T::CrossAccountId>,274		),275		Value = u128,276		QueryKind = ValueQuery,277	>;278279	#[pallet::hooks]280	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {281		fn on_runtime_upgrade() -> Weight {282			let storage_version = StorageVersion::get::<Pallet<T>>();283			if storage_version < StorageVersion::new(2) {284				<TokenData<T>>::remove_all(None);285			}286			StorageVersion::new(2).put::<Pallet<T>>();287288			Weight::zero()289		}290	}291}292293pub struct RefungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);294impl<T: Config> RefungibleHandle<T> {295	pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {296		Self(inner)297	}298	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {299		self.0300	}301	pub fn common_mut(&mut self) -> &mut pallet_common::CollectionHandle<T> {302		&mut self.0303	}304}305306impl<T: Config> Deref for RefungibleHandle<T> {307	type Target = pallet_common::CollectionHandle<T>;308309	fn deref(&self) -> &Self::Target {310		&self.0311	}312}313314impl<T: Config> WithRecorder<T> for RefungibleHandle<T> {315	fn recorder(&self) -> &pallet_evm_coder_substrate::SubstrateRecorder<T> {316		self.0.recorder()317	}318	fn into_recorder(self) -> pallet_evm_coder_substrate::SubstrateRecorder<T> {319		self.0.into_recorder()320	}321}322323impl<T: Config> Pallet<T> {324	/// Get number of RFT tokens in collection325	pub fn total_supply(collection: &RefungibleHandle<T>) -> u32 {326		<TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)327	}328329	/// Check that RFT token exists330	///331	/// - `token`: Token ID.332	pub fn token_exists(collection: &RefungibleHandle<T>, token: TokenId) -> bool {333		<TotalSupply<T>>::contains_key((collection.id, token))334	}335336	pub fn set_scoped_token_property(337		collection_id: CollectionId,338		token_id: TokenId,339		scope: PropertyScope,340		property: Property,341	) -> DispatchResult {342		TokenProperties::<T>::try_mutate((collection_id, token_id), |properties| {343			properties.try_scoped_set(scope, property.key, property.value)344		})345		.map_err(<CommonError<T>>::from)?;346347		Ok(())348	}349350	pub fn set_scoped_token_properties(351		collection_id: CollectionId,352		token_id: TokenId,353		scope: PropertyScope,354		properties: impl Iterator<Item = Property>,355	) -> DispatchResult {356		TokenProperties::<T>::try_mutate((collection_id, token_id), |stored_properties| {357			stored_properties.try_scoped_set_from_iter(scope, properties)358		})359		.map_err(<CommonError<T>>::from)?;360361		Ok(())362	}363}364365// unchecked calls skips any permission checks366impl<T: Config> Pallet<T> {367	/// Create RFT collection368	///369	/// `init_collection` will take non-refundable deposit for collection creation.370	///371	/// - `data`: Contains settings for collection limits and permissions.372	pub fn init_collection(373		owner: T::CrossAccountId,374		payer: T::CrossAccountId,375		data: CreateCollectionData<T::AccountId>,376	) -> Result<CollectionId, DispatchError> {377		<PalletCommon<T>>::init_collection(owner, payer, data, CollectionFlags::default())378	}379380	/// Destroy RFT collection381	///382	/// `destroy_collection` will throw error if collection contains any tokens.383	/// Only owner can destroy collection.384	pub fn destroy_collection(385		collection: RefungibleHandle<T>,386		sender: &T::CrossAccountId,387	) -> DispatchResult {388		let id = collection.id;389390		if Self::collection_has_tokens(id) {391			return Err(<CommonError<T>>::CantDestroyNotEmptyCollection.into());392		}393394		// =========395396		PalletCommon::destroy_collection(collection.0, sender)?;397398		<TokensMinted<T>>::remove(id);399		<TokensBurnt<T>>::remove(id);400		let _ = <TotalSupply<T>>::clear_prefix((id,), u32::MAX, None);401		let _ = <Balance<T>>::clear_prefix((id,), u32::MAX, None);402		let _ = <Allowance<T>>::clear_prefix((id,), u32::MAX, None);403		let _ = <Owned<T>>::clear_prefix((id,), u32::MAX, None);404		let _ = <AccountBalance<T>>::clear_prefix((id,), u32::MAX, None);405		Ok(())406	}407408	fn collection_has_tokens(collection_id: CollectionId) -> bool {409		<TotalSupply<T>>::iter_prefix((collection_id,))410			.next()411			.is_some()412	}413414	pub fn burn_token_unchecked(415		collection: &RefungibleHandle<T>,416		owner: &T::CrossAccountId,417		token_id: TokenId,418	) -> DispatchResult {419		let burnt = <TokensBurnt<T>>::get(collection.id)420			.checked_add(1)421			.ok_or(ArithmeticError::Overflow)?;422423		<TokensBurnt<T>>::insert(collection.id, burnt);424		<TokenProperties<T>>::remove((collection.id, token_id));425		<TotalSupply<T>>::remove((collection.id, token_id));426		let _ = <Balance<T>>::clear_prefix((collection.id, token_id), u32::MAX, None);427		let _ = <Allowance<T>>::clear_prefix((collection.id, token_id), u32::MAX, None);428		<PalletEvm<T>>::deposit_log(429			ERC721Events::Transfer {430				from: *owner.as_eth(),431				to: H160::default(),432				token_id: token_id.into(),433			}434			.to_log(collection_id_to_address(collection.id)),435		);436		Ok(())437	}438439	/// Burn RFT token pieces440	///441	/// `burn` will decrease total amount of token pieces and amount owned by sender.442	/// `burn` can be called even if there are multiple owners of the RFT token.443	/// If sender wouldn't have any pieces left after `burn` than she will stop being444	/// one of the owners of the token. If there is no account that owns any pieces of445	/// the token than token will be burned too.446	///447	/// - `amount`: Amount of token pieces to burn.448	/// - `token`: Token who's pieces should be burned449	/// - `collection`: Collection that contains the token450	pub fn burn(451		collection: &RefungibleHandle<T>,452		owner: &T::CrossAccountId,453		token: TokenId,454		amount: u128,455	) -> DispatchResult {456		let total_supply = <TotalSupply<T>>::get((collection.id, token))457			.checked_sub(amount)458			.ok_or(<CommonError<T>>::TokenValueTooLow)?;459460		// This was probally last owner of this token?461		if total_supply == 0 {462			// Ensure user actually owns this amount463			ensure!(464				<Balance<T>>::get((collection.id, token, owner)) == amount,465				<CommonError<T>>::TokenValueTooLow466			);467			let account_balance = <AccountBalance<T>>::get((collection.id, owner))468				.checked_sub(1)469				// Should not occur470				.ok_or(ArithmeticError::Underflow)?;471472			// =========473474			<Owned<T>>::remove((collection.id, owner, token));475			<PalletStructure<T>>::unnest_if_nested(owner, collection.id, token);476			<AccountBalance<T>>::insert((collection.id, owner), account_balance);477			Self::burn_token_unchecked(collection, owner, token)?;478			<PalletEvm<T>>::deposit_log(479				ERC20Events::Transfer {480					from: *owner.as_eth(),481					to: H160::default(),482					value: amount.into(),483				}484				.to_log(collection_id_to_address(collection.id)),485			);486			<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(487				collection.id,488				token,489				owner.clone(),490				amount,491			));492			return Ok(());493		}494495		let balance = <Balance<T>>::get((collection.id, token, owner))496			.checked_sub(amount)497			.ok_or(<CommonError<T>>::TokenValueTooLow)?;498		let account_balance = if balance == 0 {499			<AccountBalance<T>>::get((collection.id, owner))500				.checked_sub(1)501				// Should not occur502				.ok_or(ArithmeticError::Underflow)?503		} else {504			0505		};506507		// =========508509		if balance == 0 {510			<Owned<T>>::remove((collection.id, owner, token));511			<PalletStructure<T>>::unnest_if_nested(owner, collection.id, token);512			<Balance<T>>::remove((collection.id, token, owner));513			<AccountBalance<T>>::insert((collection.id, owner), account_balance);514515			if let Some(user) = Self::token_owner(collection.id, token) {516				<PalletEvm<T>>::deposit_log(517					ERC721Events::Transfer {518						from: erc::ADDRESS_FOR_PARTIALLY_OWNED_TOKENS,519						to: *user.as_eth(),520						token_id: token.into(),521					}522					.to_log(collection_id_to_address(collection.id)),523				);524			}525		} else {526			<Balance<T>>::insert((collection.id, token, owner), balance);527		}528		<TotalSupply<T>>::insert((collection.id, token), total_supply);529530		<PalletEvm<T>>::deposit_log(531			ERC20Events::Transfer {532				from: *owner.as_eth(),533				to: H160::default(),534				value: amount.into(),535			}536			.to_log(T::EvmTokenAddressMapping::token_to_address(537				collection.id,538				token,539			)),540		);541		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(542			collection.id,543			token,544			owner.clone(),545			amount,546		));547		Ok(())548	}549550	#[transactional]551	fn modify_token_properties(552		collection: &RefungibleHandle<T>,553		sender: &T::CrossAccountId,554		token_id: TokenId,555		properties: impl Iterator<Item = (PropertyKey, Option<PropertyValue>)>,556		is_token_create: bool,557		nesting_budget: &dyn Budget,558	) -> DispatchResult {559		let is_collection_admin = || collection.is_owner_or_admin(sender);560		let is_token_owner = || -> Result<bool, DispatchError> {561			let balance = collection.balance(sender.clone(), token_id);562			let total_pieces: u128 =563				Self::total_pieces(collection.id, token_id).unwrap_or(u128::MAX);564			if balance != total_pieces {565				return Ok(false);566			}567568			let is_bundle_owner = <PalletStructure<T>>::check_indirectly_owned(569				sender.clone(),570				collection.id,571				token_id,572				None,573				nesting_budget,574			)?;575576			Ok(is_bundle_owner)577		};578579		for (key, value) in properties {580			let permission = <PalletCommon<T>>::property_permissions(collection.id)581				.get(&key)582				.cloned()583				.unwrap_or_else(PropertyPermission::none);584585			let is_property_exists = TokenProperties::<T>::get((collection.id, token_id))586				.get(&key)587				.is_some();588589			match permission {590				PropertyPermission { mutable: false, .. } if is_property_exists => {591					return Err(<CommonError<T>>::NoPermission.into());592				}593594				PropertyPermission {595					collection_admin,596					token_owner,597					..598				} => {599					//TODO: investigate threats during public minting.600					let is_token_create =601						is_token_create && (collection_admin || token_owner) && value.is_some();602					if !(is_token_create603						|| (collection_admin && is_collection_admin())604						|| (token_owner && is_token_owner()?))605					{606						fail!(<CommonError<T>>::NoPermission);607					}608				}609			}610611			match value {612				Some(value) => {613					<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {614						properties.try_set(key.clone(), value)615					})616					.map_err(<CommonError<T>>::from)?;617618					<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertySet(619						collection.id,620						token_id,621						key,622					));623				}624				None => {625					<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {626						properties.remove(&key)627					})628					.map_err(<CommonError<T>>::from)?;629630					<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertyDeleted(631						collection.id,632						token_id,633						key,634					));635				}636			}637		}638639		Ok(())640	}641642	pub fn set_token_properties(643		collection: &RefungibleHandle<T>,644		sender: &T::CrossAccountId,645		token_id: TokenId,646		properties: impl Iterator<Item = Property>,647		is_token_create: bool,648		nesting_budget: &dyn Budget,649	) -> DispatchResult {650		Self::modify_token_properties(651			collection,652			sender,653			token_id,654			properties.map(|p| (p.key, Some(p.value))),655			is_token_create,656			nesting_budget,657		)658	}659660	pub fn set_token_property(661		collection: &RefungibleHandle<T>,662		sender: &T::CrossAccountId,663		token_id: TokenId,664		property: Property,665		nesting_budget: &dyn Budget,666	) -> DispatchResult {667		let is_token_create = false;668669		Self::set_token_properties(670			collection,671			sender,672			token_id,673			[property].into_iter(),674			is_token_create,675			nesting_budget,676		)677	}678679	pub fn delete_token_properties(680		collection: &RefungibleHandle<T>,681		sender: &T::CrossAccountId,682		token_id: TokenId,683		property_keys: impl Iterator<Item = PropertyKey>,684		nesting_budget: &dyn Budget,685	) -> DispatchResult {686		let is_token_create = false;687688		Self::modify_token_properties(689			collection,690			sender,691			token_id,692			property_keys.into_iter().map(|key| (key, None)),693			is_token_create,694			nesting_budget,695		)696	}697698	pub fn delete_token_property(699		collection: &RefungibleHandle<T>,700		sender: &T::CrossAccountId,701		token_id: TokenId,702		property_key: PropertyKey,703		nesting_budget: &dyn Budget,704	) -> DispatchResult {705		Self::delete_token_properties(706			collection,707			sender,708			token_id,709			[property_key].into_iter(),710			nesting_budget,711		)712	}713714	/// Transfer RFT token pieces from one account to another.715	///716	/// If the sender is no longer owns any pieces after the `transfer` than she stops being an owner of the token.717	///718	/// - `from`: Owner of token pieces to transfer.719	/// - `to`: Recepient of transfered token pieces.720	/// - `amount`: Amount of token pieces to transfer.721	/// - `token`: Token whos pieces should be transfered722	/// - `collection`: Collection that contains the token723	pub fn transfer(724		collection: &RefungibleHandle<T>,725		from: &T::CrossAccountId,726		to: &T::CrossAccountId,727		token: TokenId,728		amount: u128,729		nesting_budget: &dyn Budget,730	) -> DispatchResult {731		ensure!(732			collection.limits.transfers_enabled(),733			<CommonError<T>>::TransferNotAllowed734		);735736		if collection.permissions.access() == AccessMode::AllowList {737			collection.check_allowlist(from)?;738			collection.check_allowlist(to)?;739		}740		<PalletCommon<T>>::ensure_correct_receiver(to)?;741742		let initial_balance_from = <Balance<T>>::get((collection.id, token, from));743		let updated_balance_from = initial_balance_from744			.checked_sub(amount)745			.ok_or(<CommonError<T>>::TokenValueTooLow)?;746		let mut create_target = false;747		let from_to_differ = from != to;748		let updated_balance_to = if from != to {749			let old_balance = <Balance<T>>::get((collection.id, token, to));750			if old_balance == 0 {751				create_target = true;752			}753			Some(754				old_balance755					.checked_add(amount)756					.ok_or(ArithmeticError::Overflow)?,757			)758		} else {759			None760		};761762		let account_balance_from = if updated_balance_from == 0 {763			Some(764				<AccountBalance<T>>::get((collection.id, from))765					.checked_sub(1)766					// Should not occur767					.ok_or(ArithmeticError::Underflow)?,768			)769		} else {770			None771		};772		// Account data is created in token, AccountBalance should be increased773		// But only if from != to as we shouldn't check overflow in this case774		let account_balance_to = if create_target && from_to_differ {775			let account_balance_to = <AccountBalance<T>>::get((collection.id, to))776				.checked_add(1)777				.ok_or(ArithmeticError::Overflow)?;778			ensure!(779				account_balance_to < collection.limits.account_token_ownership_limit(),780				<CommonError<T>>::AccountTokenLimitExceeded,781			);782783			Some(account_balance_to)784		} else {785			None786		};787788		// =========789790		<PalletStructure<T>>::nest_if_sent_to_token(791			from.clone(),792			to,793			collection.id,794			token,795			nesting_budget,796		)?;797798		if let Some(updated_balance_to) = updated_balance_to {799			// from != to800			if updated_balance_from == 0 {801				<Balance<T>>::remove((collection.id, token, from));802				<PalletStructure<T>>::unnest_if_nested(from, collection.id, token);803			} else {804				<Balance<T>>::insert((collection.id, token, from), updated_balance_from);805			}806			<Balance<T>>::insert((collection.id, token, to), updated_balance_to);807			if let Some(account_balance_from) = account_balance_from {808				<AccountBalance<T>>::insert((collection.id, from), account_balance_from);809				<Owned<T>>::remove((collection.id, from, token));810			}811			if let Some(account_balance_to) = account_balance_to {812				<AccountBalance<T>>::insert((collection.id, to), account_balance_to);813				<Owned<T>>::insert((collection.id, to, token), true);814			}815		}816817		<PalletEvm<T>>::deposit_log(818			ERC20Events::Transfer {819				from: *from.as_eth(),820				to: *to.as_eth(),821				value: amount.into(),822			}823			.to_log(T::EvmTokenAddressMapping::token_to_address(824				collection.id,825				token,826			)),827		);828829		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(830			collection.id,831			token,832			from.clone(),833			to.clone(),834			amount,835		));836837		let total_supply = <TotalSupply<T>>::get((collection.id, token));838839		if amount == total_supply {840			// if token was fully owned by `from` and will be fully owned by `to` after transfer841			<PalletEvm<T>>::deposit_log(842				ERC721Events::Transfer {843					from: *from.as_eth(),844					to: *to.as_eth(),845					token_id: token.into(),846				}847				.to_log(collection_id_to_address(collection.id)),848			);849		} else if let Some(updated_balance_to) = updated_balance_to {850			// if `from` not equals `to`. This condition is needed to avoid sending event851			// when `from` fully owns token and sends part of token pieces to itself.852			if initial_balance_from == total_supply {853				// if token was fully owned by `from` and will be only partially owned by `to`854				// and `from` after transfer855				<PalletEvm<T>>::deposit_log(856					ERC721Events::Transfer {857						from: *from.as_eth(),858						to: erc::ADDRESS_FOR_PARTIALLY_OWNED_TOKENS,859						token_id: token.into(),860					}861					.to_log(collection_id_to_address(collection.id)),862				);863			} else if updated_balance_to == total_supply {864				// if token was partially owned by `from` and will be fully owned by `to` after transfer865				<PalletEvm<T>>::deposit_log(866					ERC721Events::Transfer {867						from: erc::ADDRESS_FOR_PARTIALLY_OWNED_TOKENS,868						to: *to.as_eth(),869						token_id: token.into(),870					}871					.to_log(collection_id_to_address(collection.id)),872				);873			}874		}875876		Ok(())877	}878879	/// Batched operation to create multiple RFT tokens.880	///881	/// Same as `create_item` but creates multiple tokens.882	///883	/// - `data`: Same as 'data` in `create_item` but contains data for multiple tokens.884	pub fn create_multiple_items(885		collection: &RefungibleHandle<T>,886		sender: &T::CrossAccountId,887		data: Vec<CreateItemData<T::CrossAccountId>>,888		nesting_budget: &dyn Budget,889	) -> DispatchResult {890		if !collection.is_owner_or_admin(sender) {891			ensure!(892				collection.permissions.mint_mode(),893				<CommonError<T>>::PublicMintingNotAllowed894			);895			collection.check_allowlist(sender)?;896897			for item in data.iter() {898				for user in item.users.keys() {899					collection.check_allowlist(user)?;900				}901			}902		}903904		for item in data.iter() {905			for (owner, _) in item.users.iter() {906				<PalletCommon<T>>::ensure_correct_receiver(owner)?;907			}908		}909910		// Total pieces per tokens911		let totals = data912			.iter()913			.map(|data| {914				Ok(data915					.users916					.iter()917					.map(|u| u.1)918					.try_fold(0u128, |acc, v| acc.checked_add(*v))919					.ok_or(ArithmeticError::Overflow)?)920			})921			.collect::<Result<Vec<_>, DispatchError>>()?;922		for total in &totals {923			ensure!(924				*total <= MAX_REFUNGIBLE_PIECES,925				<Error<T>>::WrongRefungiblePieces926			);927		}928929		let first_token_id = <TokensMinted<T>>::get(collection.id);930		let tokens_minted = first_token_id931			.checked_add(data.len() as u32)932			.ok_or(ArithmeticError::Overflow)?;933		ensure!(934			tokens_minted < collection.limits.token_limit(),935			<CommonError<T>>::CollectionTokenLimitExceeded936		);937938		let mut balances = BTreeMap::new();939		for data in &data {940			for owner in data.users.keys() {941				let balance = balances942					.entry(owner)943					.or_insert_with(|| <AccountBalance<T>>::get((collection.id, owner)));944				*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;945946				ensure!(947					*balance <= collection.limits.account_token_ownership_limit(),948					<CommonError<T>>::AccountTokenLimitExceeded,949				);950			}951		}952953		for (i, token) in data.iter().enumerate() {954			let token_id = TokenId(first_token_id + i as u32 + 1);955			for (to, _) in token.users.iter() {956				<PalletStructure<T>>::check_nesting(957					sender.clone(),958					to,959					collection.id,960					token_id,961					nesting_budget,962				)?;963			}964		}965966		// =========967968		with_transaction(|| {969			for (i, data) in data.iter().enumerate() {970				let token_id = first_token_id + i as u32 + 1;971				<TotalSupply<T>>::insert((collection.id, token_id), totals[i]);972973				for (user, amount) in data.users.iter() {974					if *amount == 0 {975						continue;976					}977					<Balance<T>>::insert((collection.id, token_id, &user), amount);978					<Owned<T>>::insert((collection.id, &user, TokenId(token_id)), true);979					<PalletStructure<T>>::nest_if_sent_to_token_unchecked(980						user,981						collection.id,982						TokenId(token_id),983					);984				}985986				if let Err(e) = Self::set_token_properties(987					collection,988					sender,989					TokenId(token_id),990					data.properties.clone().into_iter(),991					true,992					nesting_budget,993				) {994					return TransactionOutcome::Rollback(Err(e));995				}996			}997			TransactionOutcome::Commit(Ok(()))998		})?;9991000		<TokensMinted<T>>::insert(collection.id, tokens_minted);10011002		for (account, balance) in balances {1003			<AccountBalance<T>>::insert((collection.id, account), balance);1004		}10051006		for (i, token) in data.into_iter().enumerate() {1007			let token_id = first_token_id + i as u32 + 1;10081009			let receivers = token1010				.users1011				.into_iter()1012				.filter(|(_, amount)| *amount > 0)1013				.collect::<Vec<_>>();10141015			if let [(user, _)] = receivers.as_slice() {1016				// if there is exactly one receiver1017				<PalletEvm<T>>::deposit_log(1018					ERC721Events::Transfer {1019						from: H160::default(),1020						to: *user.as_eth(),1021						token_id: token_id.into(),1022					}1023					.to_log(collection_id_to_address(collection.id)),1024				);1025			} else if let [_, ..] = receivers.as_slice() {1026				// if there is more than one receiver1027				<PalletEvm<T>>::deposit_log(1028					ERC721Events::Transfer {1029						from: H160::default(),1030						to: erc::ADDRESS_FOR_PARTIALLY_OWNED_TOKENS,1031						token_id: token_id.into(),1032					}1033					.to_log(collection_id_to_address(collection.id)),1034				);1035			}10361037			for (user, amount) in receivers.into_iter() {1038				<PalletEvm<T>>::deposit_log(1039					ERC20Events::Transfer {1040						from: H160::default(),1041						to: *user.as_eth(),1042						value: amount.into(),1043					}1044					.to_log(T::EvmTokenAddressMapping::token_to_address(1045						collection.id,1046						TokenId(token_id),1047					)),1048				);1049				<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(1050					collection.id,1051					TokenId(token_id),1052					user,1053					amount,1054				));1055			}1056		}1057		Ok(())1058	}10591060	pub fn set_allowance_unchecked(1061		collection: &RefungibleHandle<T>,1062		sender: &T::CrossAccountId,1063		spender: &T::CrossAccountId,1064		token: TokenId,1065		amount: u128,1066	) {1067		if amount == 0 {1068			<Allowance<T>>::remove((collection.id, token, sender, spender));1069		} else {1070			<Allowance<T>>::insert((collection.id, token, sender, spender), amount);1071		}10721073		<PalletEvm<T>>::deposit_log(1074			ERC20Events::Approval {1075				owner: *sender.as_eth(),1076				spender: *spender.as_eth(),1077				value: amount.into(),1078			}1079			.to_log(T::EvmTokenAddressMapping::token_to_address(1080				collection.id,1081				token,1082			)),1083		);1084		<PalletCommon<T>>::deposit_event(CommonEvent::Approved(1085			collection.id,1086			token,1087			sender.clone(),1088			spender.clone(),1089			amount,1090		))1091	}10921093	/// Set allowance for the spender to `transfer` or `burn` sender's token pieces.1094	///1095	/// - `amount`: Amount of token pieces the spender is allowed to `transfer` or `burn.1096	pub fn set_allowance(1097		collection: &RefungibleHandle<T>,1098		sender: &T::CrossAccountId,1099		spender: &T::CrossAccountId,1100		token: TokenId,1101		amount: u128,1102	) -> DispatchResult {1103		if collection.permissions.access() == AccessMode::AllowList {1104			collection.check_allowlist(sender)?;1105			collection.check_allowlist(spender)?;1106		}11071108		<PalletCommon<T>>::ensure_correct_receiver(spender)?;11091110		if <Balance<T>>::get((collection.id, token, sender)) < amount {1111			ensure!(1112				collection.ignores_owned_amount(sender) && Self::token_exists(collection, token),1113				<CommonError<T>>::CantApproveMoreThanOwned1114			);1115		}11161117		// =========11181119		Self::set_allowance_unchecked(collection, sender, spender, token, amount);1120		Ok(())1121	}11221123	/// Returns allowance, which should be set after transaction1124	fn check_allowed(1125		collection: &RefungibleHandle<T>,1126		spender: &T::CrossAccountId,1127		from: &T::CrossAccountId,1128		token: TokenId,1129		amount: u128,1130		nesting_budget: &dyn Budget,1131	) -> Result<Option<u128>, DispatchError> {1132		if spender.conv_eq(from) {1133			return Ok(None);1134		}1135		if collection.permissions.access() == AccessMode::AllowList {1136			// `from`, `to` checked in [`transfer`]1137			collection.check_allowlist(spender)?;1138		}1139		if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {1140			// TODO: should collection owner be allowed to perform this transfer?1141			ensure!(1142				<PalletStructure<T>>::check_indirectly_owned(1143					spender.clone(),1144					source.0,1145					source.1,1146					None,1147					nesting_budget1148				)?,1149				<CommonError<T>>::ApprovedValueTooLow,1150			);1151			return Ok(None);1152		}1153		let allowance =1154			<Allowance<T>>::get((collection.id, token, from, &spender)).checked_sub(amount);1155		if allowance.is_none() {1156			ensure!(1157				collection.ignores_allowance(spender),1158				<CommonError<T>>::ApprovedValueTooLow1159			);1160		}1161		Ok(allowance)1162	}11631164	/// Transfer RFT token pieces from one account to another.1165	///1166	/// Same as the [`transfer`] but spender doesn't needs to be an owner of the token pieces.1167	/// The owner should set allowance for the spender to transfer pieces.1168	///1169	/// [`transfer`]: struct.Pallet.html#method.transfer1170	pub fn transfer_from(1171		collection: &RefungibleHandle<T>,1172		spender: &T::CrossAccountId,1173		from: &T::CrossAccountId,1174		to: &T::CrossAccountId,1175		token: TokenId,1176		amount: u128,1177		nesting_budget: &dyn Budget,1178	) -> DispatchResult {1179		let allowance =1180			Self::check_allowed(collection, spender, from, token, amount, nesting_budget)?;11811182		// =========11831184		Self::transfer(collection, from, to, token, amount, nesting_budget)?;1185		if let Some(allowance) = allowance {1186			Self::set_allowance_unchecked(collection, from, spender, token, allowance);1187		}1188		Ok(())1189	}11901191	/// Burn RFT token pieces from the account.1192	///1193	/// Same as the [`burn`] but spender doesn't need to be an owner of the token pieces. The owner should1194	/// set allowance for the spender to burn pieces1195	///1196	/// [`burn`]: struct.Pallet.html#method.burn1197	pub fn burn_from(1198		collection: &RefungibleHandle<T>,1199		spender: &T::CrossAccountId,1200		from: &T::CrossAccountId,1201		token: TokenId,1202		amount: u128,1203		nesting_budget: &dyn Budget,1204	) -> DispatchResult {1205		let allowance =1206			Self::check_allowed(collection, spender, from, token, amount, nesting_budget)?;12071208		// =========12091210		Self::burn(collection, from, token, amount)?;1211		if let Some(allowance) = allowance {1212			Self::set_allowance_unchecked(collection, from, spender, token, allowance);1213		}1214		Ok(())1215	}12161217	/// Create RFT token.1218	///1219	/// The sender should be the owner/admin of the collection or collection should be configured1220	/// to allow public minting.1221	///1222	/// - `data`: Contains list of users who will become the owners of the token pieces and amount1223	///   of token pieces they will receive.1224	pub fn create_item(1225		collection: &RefungibleHandle<T>,1226		sender: &T::CrossAccountId,1227		data: CreateItemData<T::CrossAccountId>,1228		nesting_budget: &dyn Budget,1229	) -> DispatchResult {1230		Self::create_multiple_items(collection, sender, vec![data], nesting_budget)1231	}12321233	/// Repartition RFT token.1234	///1235	/// `repartition` will set token balance of the sender and total amount of token pieces.1236	/// Sender should own all of the token pieces. `repartition' could be done even if some1237	/// token pieces were burned before.1238	///1239	/// - `amount`: Total amount of token pieces that the token will have after `repartition`.1240	pub fn repartition(1241		collection: &RefungibleHandle<T>,1242		owner: &T::CrossAccountId,1243		token: TokenId,1244		amount: u128,1245	) -> DispatchResult {1246		ensure!(1247			amount <= MAX_REFUNGIBLE_PIECES,1248			<Error<T>>::WrongRefungiblePieces1249		);1250		ensure!(amount > 0, <CommonError<T>>::TokenValueTooLow);1251		// Ensure user owns all pieces1252		let total_pieces = Self::total_pieces(collection.id, token).unwrap_or(u128::MAX);1253		let balance = <Balance<T>>::get((collection.id, token, owner));1254		ensure!(1255			total_pieces == balance,1256			<Error<T>>::RepartitionWhileNotOwningAllPieces1257		);12581259		<Balance<T>>::insert((collection.id, token, owner), amount);1260		<TotalSupply<T>>::insert((collection.id, token), amount);12611262		if amount > total_pieces {1263			let mint_amount = amount - total_pieces;1264			<PalletEvm<T>>::deposit_log(1265				ERC20Events::Transfer {1266					from: H160::default(),1267					to: *owner.as_eth(),1268					value: mint_amount.into(),1269				}1270				.to_log(T::EvmTokenAddressMapping::token_to_address(1271					collection.id,1272					token,1273				)),1274			);1275			<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(1276				collection.id,1277				token,1278				owner.clone(),1279				mint_amount,1280			));1281		} else if total_pieces > amount {1282			let burn_amount = total_pieces - amount;1283			<PalletEvm<T>>::deposit_log(1284				ERC20Events::Transfer {1285					from: *owner.as_eth(),1286					to: H160::default(),1287					value: burn_amount.into(),1288				}1289				.to_log(T::EvmTokenAddressMapping::token_to_address(1290					collection.id,1291					token,1292				)),1293			);1294			<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(1295				collection.id,1296				token,1297				owner.clone(),1298				burn_amount,1299			));1300		}13011302		Ok(())1303	}13041305	fn token_owner(collection_id: CollectionId, token_id: TokenId) -> Option<T::CrossAccountId> {1306		let mut owner = None;1307		let mut count = 0;1308		for key in Balance::<T>::iter_key_prefix((collection_id, token_id)) {1309			count += 1;1310			if count > 1 {1311				return None;1312			}1313			owner = Some(key);1314		}1315		owner1316	}13171318	fn total_pieces(collection_id: CollectionId, token_id: TokenId) -> Option<u128> {1319		<TotalSupply<T>>::try_get((collection_id, token_id)).ok()1320	}13211322	pub fn set_collection_properties(1323		collection: &RefungibleHandle<T>,1324		sender: &T::CrossAccountId,1325		properties: Vec<Property>,1326	) -> DispatchResult {1327		<PalletCommon<T>>::set_collection_properties(collection, sender, properties)1328	}13291330	pub fn delete_collection_properties(1331		collection: &RefungibleHandle<T>,1332		sender: &T::CrossAccountId,1333		property_keys: Vec<PropertyKey>,1334	) -> DispatchResult {1335		<PalletCommon<T>>::delete_collection_properties(collection, sender, property_keys)1336	}13371338	pub fn set_token_property_permissions(1339		collection: &RefungibleHandle<T>,1340		sender: &T::CrossAccountId,1341		property_permissions: Vec<PropertyKeyPermission>,1342	) -> DispatchResult {1343		<PalletCommon<T>>::set_token_property_permissions(collection, sender, property_permissions)1344	}13451346	pub fn set_scoped_token_property_permissions(1347		collection: &RefungibleHandle<T>,1348		sender: &T::CrossAccountId,1349		scope: PropertyScope,1350		property_permissions: Vec<PropertyKeyPermission>,1351	) -> DispatchResult {1352		<PalletCommon<T>>::set_scoped_token_property_permissions(1353			collection,1354			sender,1355			scope,1356			property_permissions,1357		)1358	}13591360	/// Returns 10 token in no particular order.1361	///1362	/// There is no direct way to get token holders in ascending order,1363	/// since `iter_prefix` returns values in no particular order.1364	/// Therefore, getting the 10 largest holders with a large value of holders1365	/// can lead to impact memory allocation + sorting with  `n * log (n)`.1366	pub fn token_owners(1367		collection_id: CollectionId,1368		token: TokenId,1369	) -> Option<Vec<T::CrossAccountId>> {1370		let res: Vec<T::CrossAccountId> = <Balance<T>>::iter_prefix((collection_id, token))1371			.map(|(owner, _amount)| owner)1372			.take(10)1373			.collect();13741375		if res.is_empty() {1376			None1377		} else {1378			Some(res)1379		}1380	}1381}