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

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, Error as CommonError, eth::collection_id_to_address,103	Event as CommonEvent, Pallet as PalletCommon,104};105use pallet_structure::Pallet as PalletStructure;106use scale_info::TypeInfo;107use sp_core::H160;108use sp_runtime::{ArithmeticError, DispatchError, DispatchResult, TransactionOutcome};109use sp_std::{vec::Vec, vec, collections::btree_map::BTreeMap};110use up_data_structs::{111	AccessMode, budget::Budget, CollectionId, CollectionFlags, CollectionPropertiesVec,112	CreateCollectionData, CustomDataLimit, mapping::TokenAddressMapping, MAX_ITEMS_PER_BATCH,113	MAX_REFUNGIBLE_PIECES, Property, PropertyKey, PropertyKeyPermission, PropertyPermission,114	PropertyScope, PropertyValue, TokenId, TrySetProperty,115};116use frame_support::BoundedBTreeMap;117use derivative::Derivative;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)]140#[deprecated(since = "0.2.0", note = "ItemData is no more contains usefull data")]141pub struct ItemData {142	pub const_data: BoundedVec<u8, CustomDataLimit>,143144	#[version(..2)]145	pub variable_data: BoundedVec<u8, CustomDataLimit>,146}147148#[frame_support::pallet]149pub mod pallet {150	use super::*;151	use frame_support::{152		Blake2_128, Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key,153		traits::StorageVersion,154	};155	use frame_system::pallet_prelude::*;156	use up_data_structs::{CollectionId, TokenId};157	use super::weights::WeightInfo;158159	#[pallet::error]160	pub enum Error<T> {161		/// Not Refungible item data used to mint in Refungible collection.162		NotRefungibleDataUsedToMintFungibleCollectionToken,163		/// Maximum refungibility exceeded.164		WrongRefungiblePieces,165		/// Refungible token can't be repartitioned by user who isn't owns all pieces.166		RepartitionWhileNotOwningAllPieces,167		/// Refungible token can't nest other tokens.168		RefungibleDisallowsNesting,169		/// Setting item properties is not allowed.170		SettingPropertiesNotAllowed,171	}172173	#[pallet::config]174	pub trait Config:175		frame_system::Config + pallet_common::Config + pallet_structure::Config176	{177		type WeightInfo: WeightInfo;178	}179180	const STORAGE_VERSION: StorageVersion = StorageVersion::new(2);181182	#[pallet::pallet]183	#[pallet::storage_version(STORAGE_VERSION)]184	#[pallet::generate_store(pub(super) trait Store)]185	pub struct Pallet<T>(_);186187	/// Total amount of minted tokens in a collection.188	#[pallet::storage]189	pub type TokensMinted<T: Config> =190		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;191192	/// Amount of tokens burnt in a collection.193	#[pallet::storage]194	pub type TokensBurnt<T: Config> =195		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;196197	/// Token data, used to partially describe a token.198	// TODO: remove199	#[pallet::storage]200	#[deprecated(since = "0.2.0", note = "ItemData is no more contains usefull data")]201	pub type TokenData<T: Config> = StorageNMap<202		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),203		Value = ItemData,204		QueryKind = ValueQuery,205	>;206207	/// Amount of pieces a refungible token is split into.208	#[pallet::storage]209	#[pallet::getter(fn token_properties)]210	pub type TokenProperties<T: Config> = StorageNMap<211		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),212		Value = up_data_structs::Properties,213		QueryKind = ValueQuery,214		OnEmpty = up_data_structs::TokenProperties,215	>;216217	/// Total amount of pieces for token218	#[pallet::storage]219	pub type TotalSupply<T: Config> = StorageNMap<220		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),221		Value = u128,222		QueryKind = ValueQuery,223	>;224225	/// Used to enumerate tokens owned by account.226	#[pallet::storage]227	pub type Owned<T: Config> = StorageNMap<228		Key = (229			Key<Twox64Concat, CollectionId>,230			Key<Blake2_128Concat, T::CrossAccountId>,231			Key<Twox64Concat, TokenId>,232		),233		Value = bool,234		QueryKind = ValueQuery,235	>;236237	/// Amount of tokens (not pieces) partially owned by an account within a collection.238	#[pallet::storage]239	pub type AccountBalance<T: Config> = StorageNMap<240		Key = (241			Key<Twox64Concat, CollectionId>,242			// Owner243			Key<Blake2_128Concat, T::CrossAccountId>,244		),245		Value = u32,246		QueryKind = ValueQuery,247	>;248249	/// Amount of token pieces owned by account.250	#[pallet::storage]251	pub type Balance<T: Config> = StorageNMap<252		Key = (253			Key<Twox64Concat, CollectionId>,254			Key<Twox64Concat, TokenId>,255			// Owner256			Key<Blake2_128Concat, T::CrossAccountId>,257		),258		Value = u128,259		QueryKind = ValueQuery,260	>;261262	/// Allowance set by a token owner for another user to perform one of certain transactions on a number of pieces of a token.263	#[pallet::storage]264	pub type Allowance<T: Config> = StorageNMap<265		Key = (266			Key<Twox64Concat, CollectionId>,267			Key<Twox64Concat, TokenId>,268			// Owner269			Key<Blake2_128, T::CrossAccountId>,270			// Spender271			Key<Blake2_128Concat, T::CrossAccountId>,272		),273		Value = u128,274		QueryKind = ValueQuery,275	>;276277	#[pallet::hooks]278	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {279		fn on_runtime_upgrade() -> Weight {280			let storage_version = StorageVersion::get::<Pallet<T>>();281			if storage_version < StorageVersion::new(2) {282				<TokenData<T>>::remove_all(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	) -> Result<CollectionId, DispatchError> {375		<PalletCommon<T>>::init_collection(owner, payer, data, CollectionFlags::default())376	}377378	/// Destroy RFT collection379	///380	/// `destroy_collection` will throw error if collection contains any tokens.381	/// Only owner can destroy collection.382	pub fn destroy_collection(383		collection: RefungibleHandle<T>,384		sender: &T::CrossAccountId,385	) -> DispatchResult {386		let id = collection.id;387388		if Self::collection_has_tokens(id) {389			return Err(<CommonError<T>>::CantDestroyNotEmptyCollection.into());390		}391392		// =========393394		PalletCommon::destroy_collection(collection.0, sender)?;395396		<TokensMinted<T>>::remove(id);397		<TokensBurnt<T>>::remove(id);398		let _ = <TotalSupply<T>>::clear_prefix((id,), u32::MAX, None);399		let _ = <Balance<T>>::clear_prefix((id,), u32::MAX, None);400		let _ = <Allowance<T>>::clear_prefix((id,), u32::MAX, None);401		let _ = <Owned<T>>::clear_prefix((id,), u32::MAX, None);402		let _ = <AccountBalance<T>>::clear_prefix((id,), u32::MAX, None);403		Ok(())404	}405406	fn collection_has_tokens(collection_id: CollectionId) -> bool {407		<TotalSupply<T>>::iter_prefix((collection_id,))408			.next()409			.is_some()410	}411412	pub fn burn_token_unchecked(413		collection: &RefungibleHandle<T>,414		owner: &T::CrossAccountId,415		token_id: TokenId,416	) -> DispatchResult {417		let burnt = <TokensBurnt<T>>::get(collection.id)418			.checked_add(1)419			.ok_or(ArithmeticError::Overflow)?;420421		<TokensBurnt<T>>::insert(collection.id, burnt);422		<TokenProperties<T>>::remove((collection.id, token_id));423		<TotalSupply<T>>::remove((collection.id, token_id));424		let _ = <Balance<T>>::clear_prefix((collection.id, token_id), u32::MAX, None);425		let _ = <Allowance<T>>::clear_prefix((collection.id, token_id), u32::MAX, None);426		<PalletEvm<T>>::deposit_log(427			ERC721Events::Transfer {428				from: *owner.as_eth(),429				to: H160::default(),430				token_id: token_id.into(),431			}432			.to_log(collection_id_to_address(collection.id)),433		);434		Ok(())435	}436437	/// Burn RFT token pieces438	///439	/// `burn` will decrease total amount of token pieces and amount owned by sender.440	/// `burn` can be called even if there are multiple owners of the RFT token.441	/// If sender wouldn't have any pieces left after `burn` than she will stop being442	/// one of the owners of the token. If there is no account that owns any pieces of443	/// the token than token will be burned too.444	///445	/// - `amount`: Amount of token pieces to burn.446	/// - `token`: Token who's pieces should be burned447	/// - `collection`: Collection that contains the token448	pub fn burn(449		collection: &RefungibleHandle<T>,450		owner: &T::CrossAccountId,451		token: TokenId,452		amount: u128,453	) -> DispatchResult {454		let total_supply = <TotalSupply<T>>::get((collection.id, token))455			.checked_sub(amount)456			.ok_or(<CommonError<T>>::TokenValueTooLow)?;457458		// This was probally last owner of this token?459		if total_supply == 0 {460			// Ensure user actually owns this amount461			ensure!(462				<Balance<T>>::get((collection.id, token, owner)) == amount,463				<CommonError<T>>::TokenValueTooLow464			);465			let account_balance = <AccountBalance<T>>::get((collection.id, owner))466				.checked_sub(1)467				// Should not occur468				.ok_or(ArithmeticError::Underflow)?;469470			// =========471472			<Owned<T>>::remove((collection.id, owner, token));473			<PalletStructure<T>>::unnest_if_nested(owner, collection.id, token);474			<AccountBalance<T>>::insert((collection.id, owner), account_balance);475			Self::burn_token_unchecked(collection, owner, token)?;476			<PalletEvm<T>>::deposit_log(477				ERC20Events::Transfer {478					from: *owner.as_eth(),479					to: H160::default(),480					value: amount.into(),481				}482				.to_log(collection_id_to_address(collection.id)),483			);484			<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(485				collection.id,486				token,487				owner.clone(),488				amount,489			));490			return Ok(());491		}492493		let balance = <Balance<T>>::get((collection.id, token, owner))494			.checked_sub(amount)495			.ok_or(<CommonError<T>>::TokenValueTooLow)?;496		let account_balance = if balance == 0 {497			<AccountBalance<T>>::get((collection.id, owner))498				.checked_sub(1)499				// Should not occur500				.ok_or(ArithmeticError::Underflow)?501		} else {502			0503		};504505		// =========506507		if balance == 0 {508			<Owned<T>>::remove((collection.id, owner, token));509			<PalletStructure<T>>::unnest_if_nested(owner, collection.id, token);510			<Balance<T>>::remove((collection.id, token, owner));511			<AccountBalance<T>>::insert((collection.id, owner), account_balance);512513			if let Some(user) = Self::token_owner(collection.id, token) {514				<PalletEvm<T>>::deposit_log(515					ERC721Events::Transfer {516						from: erc::ADDRESS_FOR_PARTIALLY_OWNED_TOKENS,517						to: *user.as_eth(),518						token_id: token.into(),519					}520					.to_log(collection_id_to_address(collection.id)),521				);522			}523		} else {524			<Balance<T>>::insert((collection.id, token, owner), balance);525		}526		<TotalSupply<T>>::insert((collection.id, token), total_supply);527528		<PalletEvm<T>>::deposit_log(529			ERC20Events::Transfer {530				from: *owner.as_eth(),531				to: H160::default(),532				value: amount.into(),533			}534			.to_log(T::EvmTokenAddressMapping::token_to_address(535				collection.id,536				token,537			)),538		);539		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(540			collection.id,541			token,542			owner.clone(),543			amount,544		));545		Ok(())546	}547548	#[transactional]549	fn modify_token_properties(550		collection: &RefungibleHandle<T>,551		sender: &T::CrossAccountId,552		token_id: TokenId,553		properties: impl Iterator<Item = (PropertyKey, Option<PropertyValue>)>,554		is_token_create: bool,555		nesting_budget: &dyn Budget,556	) -> DispatchResult {557		let is_collection_admin = || collection.is_owner_or_admin(sender);558		let is_token_owner = || -> Result<bool, DispatchError> {559			let balance = collection.balance(sender.clone(), token_id);560			let total_pieces: u128 =561				Self::total_pieces(collection.id, token_id).unwrap_or(u128::MAX);562			if balance != total_pieces {563				return Ok(false);564			}565566			let is_bundle_owner = <PalletStructure<T>>::check_indirectly_owned(567				sender.clone(),568				collection.id,569				token_id,570				None,571				nesting_budget,572			)?;573574			Ok(is_bundle_owner)575		};576577		for (key, value) in properties {578			let permission = <PalletCommon<T>>::property_permissions(collection.id)579				.get(&key)580				.cloned()581				.unwrap_or_else(PropertyPermission::none);582583			let is_property_exists = TokenProperties::<T>::get((collection.id, token_id))584				.get(&key)585				.is_some();586587			match permission {588				PropertyPermission { mutable: false, .. } if is_property_exists => {589					return Err(<CommonError<T>>::NoPermission.into());590				}591592				PropertyPermission {593					collection_admin,594					token_owner,595					..596				} => {597					//TODO: investigate threats during public minting.598					let is_token_create =599						is_token_create && (collection_admin || token_owner) && value.is_some();600					if !(is_token_create601						|| (collection_admin && is_collection_admin())602						|| (token_owner && is_token_owner()?))603					{604						fail!(<CommonError<T>>::NoPermission);605					}606				}607			}608609			match value {610				Some(value) => {611					<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {612						properties.try_set(key.clone(), value)613					})614					.map_err(<CommonError<T>>::from)?;615616					<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertySet(617						collection.id,618						token_id,619						key,620					));621				}622				None => {623					<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {624						properties.remove(&key)625					})626					.map_err(<CommonError<T>>::from)?;627628					<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertyDeleted(629						collection.id,630						token_id,631						key,632					));633				}634			}635		}636637		Ok(())638	}639640	pub fn set_token_properties(641		collection: &RefungibleHandle<T>,642		sender: &T::CrossAccountId,643		token_id: TokenId,644		properties: impl Iterator<Item = Property>,645		is_token_create: bool,646		nesting_budget: &dyn Budget,647	) -> DispatchResult {648		Self::modify_token_properties(649			collection,650			sender,651			token_id,652			properties.map(|p| (p.key, Some(p.value))),653			is_token_create,654			nesting_budget,655		)656	}657658	pub fn set_token_property(659		collection: &RefungibleHandle<T>,660		sender: &T::CrossAccountId,661		token_id: TokenId,662		property: Property,663		nesting_budget: &dyn Budget,664	) -> DispatchResult {665		let is_token_create = false;666667		Self::set_token_properties(668			collection,669			sender,670			token_id,671			[property].into_iter(),672			is_token_create,673			nesting_budget,674		)675	}676677	pub fn delete_token_properties(678		collection: &RefungibleHandle<T>,679		sender: &T::CrossAccountId,680		token_id: TokenId,681		property_keys: impl Iterator<Item = PropertyKey>,682		nesting_budget: &dyn Budget,683	) -> DispatchResult {684		let is_token_create = false;685686		Self::modify_token_properties(687			collection,688			sender,689			token_id,690			property_keys.into_iter().map(|key| (key, None)),691			is_token_create,692			nesting_budget,693		)694	}695696	pub fn delete_token_property(697		collection: &RefungibleHandle<T>,698		sender: &T::CrossAccountId,699		token_id: TokenId,700		property_key: PropertyKey,701		nesting_budget: &dyn Budget,702	) -> DispatchResult {703		Self::delete_token_properties(704			collection,705			sender,706			token_id,707			[property_key].into_iter(),708			nesting_budget,709		)710	}711712	/// Transfer RFT token pieces from one account to another.713	///714	/// If the sender is no longer owns any pieces after the `transfer` than she stops being an owner of the token.715	///716	/// - `from`: Owner of token pieces to transfer.717	/// - `to`: Recepient of transfered token pieces.718	/// - `amount`: Amount of token pieces to transfer.719	/// - `token`: Token whos pieces should be transfered720	/// - `collection`: Collection that contains the token721	pub fn transfer(722		collection: &RefungibleHandle<T>,723		from: &T::CrossAccountId,724		to: &T::CrossAccountId,725		token: TokenId,726		amount: u128,727		nesting_budget: &dyn Budget,728	) -> DispatchResult {729		ensure!(730			collection.limits.transfers_enabled(),731			<CommonError<T>>::TransferNotAllowed732		);733734		if collection.permissions.access() == AccessMode::AllowList {735			collection.check_allowlist(from)?;736			collection.check_allowlist(to)?;737		}738		<PalletCommon<T>>::ensure_correct_receiver(to)?;739740		let initial_balance_from = <Balance<T>>::get((collection.id, token, from));741		let updated_balance_from = initial_balance_from742			.checked_sub(amount)743			.ok_or(<CommonError<T>>::TokenValueTooLow)?;744		let mut create_target = false;745		let from_to_differ = from != to;746		let updated_balance_to = if from != to {747			let old_balance = <Balance<T>>::get((collection.id, token, to));748			if old_balance == 0 {749				create_target = true;750			}751			Some(752				old_balance753					.checked_add(amount)754					.ok_or(ArithmeticError::Overflow)?,755			)756		} else {757			None758		};759760		let account_balance_from = if updated_balance_from == 0 {761			Some(762				<AccountBalance<T>>::get((collection.id, from))763					.checked_sub(1)764					// Should not occur765					.ok_or(ArithmeticError::Underflow)?,766			)767		} else {768			None769		};770		// Account data is created in token, AccountBalance should be increased771		// But only if from != to as we shouldn't check overflow in this case772		let account_balance_to = if create_target && from_to_differ {773			let account_balance_to = <AccountBalance<T>>::get((collection.id, to))774				.checked_add(1)775				.ok_or(ArithmeticError::Overflow)?;776			ensure!(777				account_balance_to < collection.limits.account_token_ownership_limit(),778				<CommonError<T>>::AccountTokenLimitExceeded,779			);780781			Some(account_balance_to)782		} else {783			None784		};785786		// =========787788		<PalletStructure<T>>::nest_if_sent_to_token(789			from.clone(),790			to,791			collection.id,792			token,793			nesting_budget,794		)?;795796		if let Some(updated_balance_to) = updated_balance_to {797			// from != to798			if updated_balance_from == 0 {799				<Balance<T>>::remove((collection.id, token, from));800				<PalletStructure<T>>::unnest_if_nested(from, collection.id, token);801			} else {802				<Balance<T>>::insert((collection.id, token, from), updated_balance_from);803			}804			<Balance<T>>::insert((collection.id, token, to), updated_balance_to);805			if let Some(account_balance_from) = account_balance_from {806				<AccountBalance<T>>::insert((collection.id, from), account_balance_from);807				<Owned<T>>::remove((collection.id, from, token));808			}809			if let Some(account_balance_to) = account_balance_to {810				<AccountBalance<T>>::insert((collection.id, to), account_balance_to);811				<Owned<T>>::insert((collection.id, to, token), true);812			}813		}814815		<PalletEvm<T>>::deposit_log(816			ERC20Events::Transfer {817				from: *from.as_eth(),818				to: *to.as_eth(),819				value: amount.into(),820			}821			.to_log(T::EvmTokenAddressMapping::token_to_address(822				collection.id,823				token,824			)),825		);826827		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(828			collection.id,829			token,830			from.clone(),831			to.clone(),832			amount,833		));834835		let total_supply = <TotalSupply<T>>::get((collection.id, token));836837		if amount == total_supply {838			// if token was fully owned by `from` and will be fully owned by `to` after transfer839			<PalletEvm<T>>::deposit_log(840				ERC721Events::Transfer {841					from: *from.as_eth(),842					to: *to.as_eth(),843					token_id: token.into(),844				}845				.to_log(collection_id_to_address(collection.id)),846			);847		} else if let Some(updated_balance_to) = updated_balance_to {848			// if `from` not equals `to`. This condition is needed to avoid sending event849			// when `from` fully owns token and sends part of token pieces to itself.850			if initial_balance_from == total_supply {851				// if token was fully owned by `from` and will be only partially owned by `to`852				// and `from` after transfer853				<PalletEvm<T>>::deposit_log(854					ERC721Events::Transfer {855						from: *from.as_eth(),856						to: erc::ADDRESS_FOR_PARTIALLY_OWNED_TOKENS,857						token_id: token.into(),858					}859					.to_log(collection_id_to_address(collection.id)),860				);861			} else if updated_balance_to == total_supply {862				// if token was partially owned by `from` and will be fully owned by `to` after transfer863				<PalletEvm<T>>::deposit_log(864					ERC721Events::Transfer {865						from: erc::ADDRESS_FOR_PARTIALLY_OWNED_TOKENS,866						to: *to.as_eth(),867						token_id: token.into(),868					}869					.to_log(collection_id_to_address(collection.id)),870				);871			}872		}873874		Ok(())875	}876877	/// Batched operation to create multiple RFT tokens.878	///879	/// Same as `create_item` but creates multiple tokens.880	///881	/// - `data`: Same as 'data` in `create_item` but contains data for multiple tokens.882	pub fn create_multiple_items(883		collection: &RefungibleHandle<T>,884		sender: &T::CrossAccountId,885		data: Vec<CreateItemData<T::CrossAccountId>>,886		nesting_budget: &dyn Budget,887	) -> DispatchResult {888		if !collection.is_owner_or_admin(sender) {889			ensure!(890				collection.permissions.mint_mode(),891				<CommonError<T>>::PublicMintingNotAllowed892			);893			collection.check_allowlist(sender)?;894895			for item in data.iter() {896				for user in item.users.keys() {897					collection.check_allowlist(user)?;898				}899			}900		}901902		for item in data.iter() {903			for (owner, _) in item.users.iter() {904				<PalletCommon<T>>::ensure_correct_receiver(owner)?;905			}906		}907908		// Total pieces per tokens909		let totals = data910			.iter()911			.map(|data| {912				Ok(data913					.users914					.iter()915					.map(|u| u.1)916					.try_fold(0u128, |acc, v| acc.checked_add(*v))917					.ok_or(ArithmeticError::Overflow)?)918			})919			.collect::<Result<Vec<_>, DispatchError>>()?;920		for total in &totals {921			ensure!(922				*total <= MAX_REFUNGIBLE_PIECES,923				<Error<T>>::WrongRefungiblePieces924			);925		}926927		let first_token_id = <TokensMinted<T>>::get(collection.id);928		let tokens_minted = first_token_id929			.checked_add(data.len() as u32)930			.ok_or(ArithmeticError::Overflow)?;931		ensure!(932			tokens_minted < collection.limits.token_limit(),933			<CommonError<T>>::CollectionTokenLimitExceeded934		);935936		let mut balances = BTreeMap::new();937		for data in &data {938			for owner in data.users.keys() {939				let balance = balances940					.entry(owner)941					.or_insert_with(|| <AccountBalance<T>>::get((collection.id, owner)));942				*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;943944				ensure!(945					*balance <= collection.limits.account_token_ownership_limit(),946					<CommonError<T>>::AccountTokenLimitExceeded,947				);948			}949		}950951		for (i, token) in data.iter().enumerate() {952			let token_id = TokenId(first_token_id + i as u32 + 1);953			for (to, _) in token.users.iter() {954				<PalletStructure<T>>::check_nesting(955					sender.clone(),956					to,957					collection.id,958					token_id,959					nesting_budget,960				)?;961			}962		}963964		// =========965966		with_transaction(|| {967			for (i, data) in data.iter().enumerate() {968				let token_id = first_token_id + i as u32 + 1;969				<TotalSupply<T>>::insert((collection.id, token_id), totals[i]);970971				for (user, amount) in data.users.iter() {972					if *amount == 0 {973						continue;974					}975					<Balance<T>>::insert((collection.id, token_id, &user), amount);976					<Owned<T>>::insert((collection.id, &user, TokenId(token_id)), true);977					<PalletStructure<T>>::nest_if_sent_to_token_unchecked(978						user,979						collection.id,980						TokenId(token_id),981					);982				}983984				if let Err(e) = Self::set_token_properties(985					collection,986					sender,987					TokenId(token_id),988					data.properties.clone().into_iter(),989					true,990					nesting_budget,991				) {992					return TransactionOutcome::Rollback(Err(e));993				}994			}995			TransactionOutcome::Commit(Ok(()))996		})?;997998		<TokensMinted<T>>::insert(collection.id, tokens_minted);9991000		for (account, balance) in balances {1001			<AccountBalance<T>>::insert((collection.id, account), balance);1002		}10031004		for (i, token) in data.into_iter().enumerate() {1005			let token_id = first_token_id + i as u32 + 1;10061007			let receivers = token1008				.users1009				.into_iter()1010				.filter(|(_, amount)| *amount > 0)1011				.collect::<Vec<_>>();10121013			if let [(user, _)] = receivers.as_slice() {1014				// if there is exactly one receiver1015				<PalletEvm<T>>::deposit_log(1016					ERC721Events::Transfer {1017						from: H160::default(),1018						to: *user.as_eth(),1019						token_id: token_id.into(),1020					}1021					.to_log(collection_id_to_address(collection.id)),1022				);1023			} else if let [_, ..] = receivers.as_slice() {1024				// if there is more than one receiver1025				<PalletEvm<T>>::deposit_log(1026					ERC721Events::Transfer {1027						from: H160::default(),1028						to: erc::ADDRESS_FOR_PARTIALLY_OWNED_TOKENS,1029						token_id: token_id.into(),1030					}1031					.to_log(collection_id_to_address(collection.id)),1032				);1033			}10341035			for (user, amount) in receivers.into_iter() {1036				<PalletEvm<T>>::deposit_log(1037					ERC20Events::Transfer {1038						from: H160::default(),1039						to: *user.as_eth(),1040						value: amount.into(),1041					}1042					.to_log(T::EvmTokenAddressMapping::token_to_address(1043						collection.id,1044						TokenId(token_id),1045					)),1046				);1047				<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(1048					collection.id,1049					TokenId(token_id),1050					user,1051					amount,1052				));1053			}1054		}1055		Ok(())1056	}10571058	pub fn set_allowance_unchecked(1059		collection: &RefungibleHandle<T>,1060		sender: &T::CrossAccountId,1061		spender: &T::CrossAccountId,1062		token: TokenId,1063		amount: u128,1064	) {1065		if amount == 0 {1066			<Allowance<T>>::remove((collection.id, token, sender, spender));1067		} else {1068			<Allowance<T>>::insert((collection.id, token, sender, spender), amount);1069		}10701071		<PalletEvm<T>>::deposit_log(1072			ERC20Events::Approval {1073				owner: *sender.as_eth(),1074				spender: *spender.as_eth(),1075				value: amount.into(),1076			}1077			.to_log(T::EvmTokenAddressMapping::token_to_address(1078				collection.id,1079				token,1080			)),1081		);1082		<PalletCommon<T>>::deposit_event(CommonEvent::Approved(1083			collection.id,1084			token,1085			sender.clone(),1086			spender.clone(),1087			amount,1088		))1089	}10901091	/// Set allowance for the spender to `transfer` or `burn` sender's token pieces.1092	///1093	/// - `amount`: Amount of token pieces the spender is allowed to `transfer` or `burn.1094	pub fn set_allowance(1095		collection: &RefungibleHandle<T>,1096		sender: &T::CrossAccountId,1097		spender: &T::CrossAccountId,1098		token: TokenId,1099		amount: u128,1100	) -> DispatchResult {1101		if collection.permissions.access() == AccessMode::AllowList {1102			collection.check_allowlist(sender)?;1103			collection.check_allowlist(spender)?;1104		}11051106		<PalletCommon<T>>::ensure_correct_receiver(spender)?;11071108		if <Balance<T>>::get((collection.id, token, sender)) < amount {1109			ensure!(1110				collection.ignores_owned_amount(sender) && Self::token_exists(collection, token),1111				<CommonError<T>>::CantApproveMoreThanOwned1112			);1113		}11141115		// =========11161117		Self::set_allowance_unchecked(collection, sender, spender, token, amount);1118		Ok(())1119	}11201121	/// Returns allowance, which should be set after transaction1122	fn check_allowed(1123		collection: &RefungibleHandle<T>,1124		spender: &T::CrossAccountId,1125		from: &T::CrossAccountId,1126		token: TokenId,1127		amount: u128,1128		nesting_budget: &dyn Budget,1129	) -> Result<Option<u128>, DispatchError> {1130		if spender.conv_eq(from) {1131			return Ok(None);1132		}1133		if collection.permissions.access() == AccessMode::AllowList {1134			// `from`, `to` checked in [`transfer`]1135			collection.check_allowlist(spender)?;1136		}1137		if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {1138			// TODO: should collection owner be allowed to perform this transfer?1139			ensure!(1140				<PalletStructure<T>>::check_indirectly_owned(1141					spender.clone(),1142					source.0,1143					source.1,1144					None,1145					nesting_budget1146				)?,1147				<CommonError<T>>::ApprovedValueTooLow,1148			);1149			return Ok(None);1150		}1151		let allowance =1152			<Allowance<T>>::get((collection.id, token, from, &spender)).checked_sub(amount);1153		if allowance.is_none() {1154			ensure!(1155				collection.ignores_allowance(spender),1156				<CommonError<T>>::ApprovedValueTooLow1157			);1158		}1159		Ok(allowance)1160	}11611162	/// Transfer RFT token pieces from one account to another.1163	///1164	/// Same as the [`transfer`] but spender doesn't needs to be an owner of the token pieces.1165	/// The owner should set allowance for the spender to transfer pieces.1166	///1167	/// [`transfer`]: struct.Pallet.html#method.transfer1168	pub fn transfer_from(1169		collection: &RefungibleHandle<T>,1170		spender: &T::CrossAccountId,1171		from: &T::CrossAccountId,1172		to: &T::CrossAccountId,1173		token: TokenId,1174		amount: u128,1175		nesting_budget: &dyn Budget,1176	) -> DispatchResult {1177		let allowance =1178			Self::check_allowed(collection, spender, from, token, amount, nesting_budget)?;11791180		// =========11811182		Self::transfer(collection, from, to, token, amount, nesting_budget)?;1183		if let Some(allowance) = allowance {1184			Self::set_allowance_unchecked(collection, from, spender, token, allowance);1185		}1186		Ok(())1187	}11881189	/// Burn RFT token pieces from the account.1190	///1191	/// Same as the [`burn`] but spender doesn't need to be an owner of the token pieces. The owner should1192	/// set allowance for the spender to burn pieces1193	///1194	/// [`burn`]: struct.Pallet.html#method.burn1195	pub fn burn_from(1196		collection: &RefungibleHandle<T>,1197		spender: &T::CrossAccountId,1198		from: &T::CrossAccountId,1199		token: TokenId,1200		amount: u128,1201		nesting_budget: &dyn Budget,1202	) -> DispatchResult {1203		let allowance =1204			Self::check_allowed(collection, spender, from, token, amount, nesting_budget)?;12051206		// =========12071208		Self::burn(collection, from, token, amount)?;1209		if let Some(allowance) = allowance {1210			Self::set_allowance_unchecked(collection, from, spender, token, allowance);1211		}1212		Ok(())1213	}12141215	/// Create RFT token.1216	///1217	/// The sender should be the owner/admin of the collection or collection should be configured1218	/// to allow public minting.1219	///1220	/// - `data`: Contains list of users who will become the owners of the token pieces and amount1221	///   of token pieces they will receive.1222	pub fn create_item(1223		collection: &RefungibleHandle<T>,1224		sender: &T::CrossAccountId,1225		data: CreateItemData<T::CrossAccountId>,1226		nesting_budget: &dyn Budget,1227	) -> DispatchResult {1228		Self::create_multiple_items(collection, sender, vec![data], nesting_budget)1229	}12301231	/// Repartition RFT token.1232	///1233	/// `repartition` will set token balance of the sender and total amount of token pieces.1234	/// Sender should own all of the token pieces. `repartition' could be done even if some1235	/// token pieces were burned before.1236	///1237	/// - `amount`: Total amount of token pieces that the token will have after `repartition`.1238	pub fn repartition(1239		collection: &RefungibleHandle<T>,1240		owner: &T::CrossAccountId,1241		token: TokenId,1242		amount: u128,1243	) -> DispatchResult {1244		ensure!(1245			amount <= MAX_REFUNGIBLE_PIECES,1246			<Error<T>>::WrongRefungiblePieces1247		);1248		ensure!(amount > 0, <CommonError<T>>::TokenValueTooLow);1249		// Ensure user owns all pieces1250		let total_pieces = Self::total_pieces(collection.id, token).unwrap_or(u128::MAX);1251		let balance = <Balance<T>>::get((collection.id, token, owner));1252		ensure!(1253			total_pieces == balance,1254			<Error<T>>::RepartitionWhileNotOwningAllPieces1255		);12561257		<Balance<T>>::insert((collection.id, token, owner), amount);1258		<TotalSupply<T>>::insert((collection.id, token), amount);12591260		if amount > total_pieces {1261			let mint_amount = amount - total_pieces;1262			<PalletEvm<T>>::deposit_log(1263				ERC20Events::Transfer {1264					from: H160::default(),1265					to: *owner.as_eth(),1266					value: mint_amount.into(),1267				}1268				.to_log(T::EvmTokenAddressMapping::token_to_address(1269					collection.id,1270					token,1271				)),1272			);1273			<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(1274				collection.id,1275				token,1276				owner.clone(),1277				mint_amount,1278			));1279		} else if total_pieces > amount {1280			let burn_amount = total_pieces - amount;1281			<PalletEvm<T>>::deposit_log(1282				ERC20Events::Transfer {1283					from: *owner.as_eth(),1284					to: H160::default(),1285					value: burn_amount.into(),1286				}1287				.to_log(T::EvmTokenAddressMapping::token_to_address(1288					collection.id,1289					token,1290				)),1291			);1292			<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(1293				collection.id,1294				token,1295				owner.clone(),1296				burn_amount,1297			));1298		}12991300		Ok(())1301	}13021303	fn token_owner(collection_id: CollectionId, token_id: TokenId) -> Option<T::CrossAccountId> {1304		let mut owner = None;1305		let mut count = 0;1306		for key in Balance::<T>::iter_key_prefix((collection_id, token_id)) {1307			count += 1;1308			if count > 1 {1309				return None;1310			}1311			owner = Some(key);1312		}1313		owner1314	}13151316	fn total_pieces(collection_id: CollectionId, token_id: TokenId) -> Option<u128> {1317		<TotalSupply<T>>::try_get((collection_id, token_id)).ok()1318	}13191320	pub fn set_collection_properties(1321		collection: &RefungibleHandle<T>,1322		sender: &T::CrossAccountId,1323		properties: Vec<Property>,1324	) -> DispatchResult {1325		<PalletCommon<T>>::set_collection_properties(collection, sender, properties)1326	}13271328	pub fn delete_collection_properties(1329		collection: &RefungibleHandle<T>,1330		sender: &T::CrossAccountId,1331		property_keys: Vec<PropertyKey>,1332	) -> DispatchResult {1333		<PalletCommon<T>>::delete_collection_properties(collection, sender, property_keys)1334	}13351336	pub fn set_token_property_permissions(1337		collection: &RefungibleHandle<T>,1338		sender: &T::CrossAccountId,1339		property_permissions: Vec<PropertyKeyPermission>,1340	) -> DispatchResult {1341		<PalletCommon<T>>::set_token_property_permissions(collection, sender, property_permissions)1342	}13431344	pub fn set_scoped_token_property_permissions(1345		collection: &RefungibleHandle<T>,1346		sender: &T::CrossAccountId,1347		scope: PropertyScope,1348		property_permissions: Vec<PropertyKeyPermission>,1349	) -> DispatchResult {1350		<PalletCommon<T>>::set_scoped_token_property_permissions(1351			collection,1352			sender,1353			scope,1354			property_permissions,1355		)1356	}13571358	/// Returns 10 token in no particular order.1359	///1360	/// There is no direct way to get token holders in ascending order,1361	/// since `iter_prefix` returns values in no particular order.1362	/// Therefore, getting the 10 largest holders with a large value of holders1363	/// can lead to impact memory allocation + sorting with  `n * log (n)`.1364	pub fn token_owners(1365		collection_id: CollectionId,1366		token: TokenId,1367	) -> Option<Vec<T::CrossAccountId>> {1368		let res: Vec<T::CrossAccountId> = <Balance<T>>::iter_prefix((collection_id, token))1369			.map(|(owner, _amount)| owner)1370			.take(10)1371			.collect();13721373		if res.is_empty() {1374			None1375		} else {1376			Some(res)1377		}1378	}1379}