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

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, erc::CollectionHelpersEvents,106};107use pallet_structure::Pallet as PalletStructure;108use scale_info::TypeInfo;109use sp_core::{Get, 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, PropertiesPermissionMap,117	CreateRefungibleExMultipleOwners,118};119120pub use pallet::*;121#[cfg(feature = "runtime-benchmarks")]122pub mod benchmarking;123pub mod common;124pub mod erc;125pub mod erc_token;126pub mod weights;127128pub type CreateItemData<T> =129	CreateRefungibleExMultipleOwners<<T as pallet_evm::Config>::CrossAccountId>;130pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;131132/// Token data, stored independently from other data used to describe it133/// for the convenience of database access. Notably contains the token metadata.134#[struct_versioning::versioned(version = 2, upper)]135#[derive(Encode, Decode, Default, TypeInfo, MaxEncodedLen)]136pub struct ItemData {137	pub const_data: BoundedVec<u8, CustomDataLimit>,138139	#[version(..2)]140	pub variable_data: BoundedVec<u8, CustomDataLimit>,141}142143#[frame_support::pallet]144pub mod pallet {145	use super::*;146	use frame_support::{147		Blake2_128, Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key,148		traits::StorageVersion,149	};150	use frame_system::pallet_prelude::*;151	use up_data_structs::{CollectionId, TokenId};152	use super::weights::WeightInfo;153154	#[pallet::error]155	pub enum Error<T> {156		/// Not Refungible item data used to mint in Refungible collection.157		NotRefungibleDataUsedToMintFungibleCollectionToken,158		/// Maximum refungibility exceeded.159		WrongRefungiblePieces,160		/// Refungible token can't be repartitioned by user who isn't owns all pieces.161		RepartitionWhileNotOwningAllPieces,162		/// Refungible token can't nest other tokens.163		RefungibleDisallowsNesting,164		/// Setting item properties is not allowed.165		SettingPropertiesNotAllowed,166	}167168	#[pallet::config]169	pub trait Config:170		frame_system::Config + pallet_common::Config + pallet_structure::Config171	{172		type WeightInfo: WeightInfo;173	}174175	const STORAGE_VERSION: StorageVersion = StorageVersion::new(2);176177	#[pallet::pallet]178	#[pallet::storage_version(STORAGE_VERSION)]179	#[pallet::generate_store(pub(super) trait Store)]180	pub struct Pallet<T>(_);181182	/// Total amount of minted tokens in a collection.183	#[pallet::storage]184	pub type TokensMinted<T: Config> =185		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;186187	/// Amount of tokens burnt in a collection.188	#[pallet::storage]189	pub type TokensBurnt<T: Config> =190		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;191192	/// Token data, used to partially describe a token.193	// TODO: remove194	#[pallet::storage]195	#[deprecated(since = "0.2.0", note = "ItemData is no more contains usefull data")]196	pub type TokenData<T: Config> = StorageNMap<197		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),198		Value = ItemData,199		QueryKind = ValueQuery,200	>;201202	/// Amount of pieces a refungible token is split into.203	#[pallet::storage]204	#[pallet::getter(fn token_properties)]205	pub type TokenProperties<T: Config> = StorageNMap<206		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),207		Value = up_data_structs::Properties,208		QueryKind = ValueQuery,209		OnEmpty = up_data_structs::TokenProperties,210	>;211212	/// Total amount of pieces for token213	#[pallet::storage]214	pub type TotalSupply<T: Config> = StorageNMap<215		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),216		Value = u128,217		QueryKind = ValueQuery,218	>;219220	/// Used to enumerate tokens owned by account.221	#[pallet::storage]222	pub type Owned<T: Config> = StorageNMap<223		Key = (224			Key<Twox64Concat, CollectionId>,225			Key<Blake2_128Concat, T::CrossAccountId>,226			Key<Twox64Concat, TokenId>,227		),228		Value = bool,229		QueryKind = ValueQuery,230	>;231232	/// Amount of tokens (not pieces) partially owned by an account within a collection.233	#[pallet::storage]234	pub type AccountBalance<T: Config> = StorageNMap<235		Key = (236			Key<Twox64Concat, CollectionId>,237			// Owner238			Key<Blake2_128Concat, T::CrossAccountId>,239		),240		Value = u32,241		QueryKind = ValueQuery,242	>;243244	/// Amount of token pieces owned by account.245	#[pallet::storage]246	pub type Balance<T: Config> = StorageNMap<247		Key = (248			Key<Twox64Concat, CollectionId>,249			Key<Twox64Concat, TokenId>,250			// Owner251			Key<Blake2_128Concat, T::CrossAccountId>,252		),253		Value = u128,254		QueryKind = ValueQuery,255	>;256257	/// Allowance set by a token owner for another user to perform one of certain transactions on a number of pieces of a token.258	#[pallet::storage]259	pub type Allowance<T: Config> = StorageNMap<260		Key = (261			Key<Twox64Concat, CollectionId>,262			Key<Twox64Concat, TokenId>,263			// Owner264			Key<Blake2_128, T::CrossAccountId>,265			// Spender266			Key<Blake2_128Concat, T::CrossAccountId>,267		),268		Value = u128,269		QueryKind = ValueQuery,270	>;271272	/// Operator set by a wallet owner that could perform certain transactions on all tokens in the wallet.273	#[pallet::storage]274	pub type CollectionAllowance<T: Config> = StorageNMap<275		Key = (276			Key<Twox64Concat, CollectionId>,277			Key<Blake2_128Concat, T::CrossAccountId>,278			Key<Blake2_128Concat, T::CrossAccountId>,279		),280		Value = bool,281		QueryKind = ValueQuery,282	>;283284	#[pallet::hooks]285	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {286		fn on_runtime_upgrade() -> Weight {287			let storage_version = StorageVersion::get::<Pallet<T>>();288			if storage_version < StorageVersion::new(2) {289				#[allow(deprecated)]290				let _ = <TokenData<T>>::clear(u32::MAX, None);291			}292			StorageVersion::new(2).put::<Pallet<T>>();293294			Weight::zero()295		}296	}297}298299pub struct RefungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);300impl<T: Config> RefungibleHandle<T> {301	pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {302		Self(inner)303	}304	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {305		self.0306	}307	pub fn common_mut(&mut self) -> &mut pallet_common::CollectionHandle<T> {308		&mut self.0309	}310}311312impl<T: Config> Deref for RefungibleHandle<T> {313	type Target = pallet_common::CollectionHandle<T>;314315	fn deref(&self) -> &Self::Target {316		&self.0317	}318}319320impl<T: Config> WithRecorder<T> for RefungibleHandle<T> {321	fn recorder(&self) -> &pallet_evm_coder_substrate::SubstrateRecorder<T> {322		self.0.recorder()323	}324	fn into_recorder(self) -> pallet_evm_coder_substrate::SubstrateRecorder<T> {325		self.0.into_recorder()326	}327}328329impl<T: Config> Pallet<T> {330	/// Get number of RFT tokens in collection331	pub fn total_supply(collection: &RefungibleHandle<T>) -> u32 {332		<TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)333	}334335	/// Check that RFT token exists336	///337	/// - `token`: Token ID.338	pub fn token_exists(collection: &RefungibleHandle<T>, token: TokenId) -> bool {339		<TotalSupply<T>>::contains_key((collection.id, token))340	}341342	pub fn set_scoped_token_property(343		collection_id: CollectionId,344		token_id: TokenId,345		scope: PropertyScope,346		property: Property,347	) -> DispatchResult {348		TokenProperties::<T>::try_mutate((collection_id, token_id), |properties| {349			properties.try_scoped_set(scope, property.key, property.value)350		})351		.map_err(<CommonError<T>>::from)?;352353		Ok(())354	}355356	pub fn set_scoped_token_properties(357		collection_id: CollectionId,358		token_id: TokenId,359		scope: PropertyScope,360		properties: impl Iterator<Item = Property>,361	) -> DispatchResult {362		TokenProperties::<T>::try_mutate((collection_id, token_id), |stored_properties| {363			stored_properties.try_scoped_set_from_iter(scope, properties)364		})365		.map_err(<CommonError<T>>::from)?;366367		Ok(())368	}369}370371// unchecked calls skips any permission checks372impl<T: Config> Pallet<T> {373	/// Create RFT collection374	///375	/// `init_collection` will take non-refundable deposit for collection creation.376	///377	/// - `data`: Contains settings for collection limits and permissions.378	pub fn init_collection(379		owner: T::CrossAccountId,380		payer: T::CrossAccountId,381		data: CreateCollectionData<T::AccountId>,382		flags: CollectionFlags,383	) -> Result<CollectionId, DispatchError> {384		<PalletCommon<T>>::init_collection(owner, payer, data, flags)385	}386387	/// Destroy RFT collection388	///389	/// `destroy_collection` will throw error if collection contains any tokens.390	/// Only owner can destroy collection.391	pub fn destroy_collection(392		collection: RefungibleHandle<T>,393		sender: &T::CrossAccountId,394	) -> DispatchResult {395		let id = collection.id;396397		if Self::collection_has_tokens(id) {398			return Err(<CommonError<T>>::CantDestroyNotEmptyCollection.into());399		}400401		// =========402403		PalletCommon::destroy_collection(collection.0, sender)?;404405		<TokensMinted<T>>::remove(id);406		<TokensBurnt<T>>::remove(id);407		let _ = <TotalSupply<T>>::clear_prefix((id,), u32::MAX, None);408		let _ = <Balance<T>>::clear_prefix((id,), u32::MAX, None);409		let _ = <Allowance<T>>::clear_prefix((id,), u32::MAX, None);410		let _ = <Owned<T>>::clear_prefix((id,), u32::MAX, None);411		let _ = <AccountBalance<T>>::clear_prefix((id,), u32::MAX, None);412		Ok(())413	}414415	fn collection_has_tokens(collection_id: CollectionId) -> bool {416		<TotalSupply<T>>::iter_prefix((collection_id,))417			.next()418			.is_some()419	}420421	pub fn burn_token_unchecked(422		collection: &RefungibleHandle<T>,423		owner: &T::CrossAccountId,424		token_id: TokenId,425	) -> DispatchResult {426		let burnt = <TokensBurnt<T>>::get(collection.id)427			.checked_add(1)428			.ok_or(ArithmeticError::Overflow)?;429430		<TokensBurnt<T>>::insert(collection.id, burnt);431		<TokenProperties<T>>::remove((collection.id, token_id));432		<TotalSupply<T>>::remove((collection.id, token_id));433		let _ = <Balance<T>>::clear_prefix((collection.id, token_id), u32::MAX, None);434		let _ = <Allowance<T>>::clear_prefix((collection.id, token_id), u32::MAX, None);435		<PalletEvm<T>>::deposit_log(436			ERC721Events::Transfer {437				from: *owner.as_eth(),438				to: H160::default(),439				token_id: token_id.into(),440			}441			.to_log(collection_id_to_address(collection.id)),442		);443		Ok(())444	}445446	/// Burn RFT token pieces447	///448	/// `burn` will decrease total amount of token pieces and amount owned by sender.449	/// `burn` can be called even if there are multiple owners of the RFT token.450	/// If sender wouldn't have any pieces left after `burn` than she will stop being451	/// one of the owners of the token. If there is no account that owns any pieces of452	/// the token than token will be burned too.453	///454	/// - `amount`: Amount of token pieces to burn.455	/// - `token`: Token who's pieces should be burned456	/// - `collection`: Collection that contains the token457	pub fn burn(458		collection: &RefungibleHandle<T>,459		owner: &T::CrossAccountId,460		token: TokenId,461		amount: u128,462	) -> DispatchResult {463		if <Balance<T>>::get((collection.id, token, owner)) == 0 {464			return Err(<CommonError<T>>::TokenValueTooLow.into());465		}466467		let total_supply = <TotalSupply<T>>::get((collection.id, token))468			.checked_sub(amount)469			.ok_or(<CommonError<T>>::TokenValueTooLow)?;470471		// This was probally last owner of this token?472		if total_supply == 0 {473			// Ensure user actually owns this amount474			ensure!(475				<Balance<T>>::get((collection.id, token, owner)) == amount,476				<CommonError<T>>::TokenValueTooLow477			);478			let account_balance = <AccountBalance<T>>::get((collection.id, owner))479				.checked_sub(1)480				// Should not occur481				.ok_or(ArithmeticError::Underflow)?;482483			// =========484485			<Owned<T>>::remove((collection.id, owner, token));486			<PalletStructure<T>>::unnest_if_nested(owner, collection.id, token);487			<AccountBalance<T>>::insert((collection.id, owner), account_balance);488			Self::burn_token_unchecked(collection, owner, token)?;489			<PalletEvm<T>>::deposit_log(490				ERC20Events::Transfer {491					from: *owner.as_eth(),492					to: H160::default(),493					value: amount.into(),494				}495				.to_log(collection_id_to_address(collection.id)),496			);497			<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(498				collection.id,499				token,500				owner.clone(),501				amount,502			));503			return Ok(());504		}505506		let balance = <Balance<T>>::get((collection.id, token, owner))507			.checked_sub(amount)508			.ok_or(<CommonError<T>>::TokenValueTooLow)?;509		let account_balance = if balance == 0 {510			<AccountBalance<T>>::get((collection.id, owner))511				.checked_sub(1)512				// Should not occur513				.ok_or(ArithmeticError::Underflow)?514		} else {515			0516		};517518		// =========519520		if balance == 0 {521			<Owned<T>>::remove((collection.id, owner, token));522			<PalletStructure<T>>::unnest_if_nested(owner, collection.id, token);523			<Balance<T>>::remove((collection.id, token, owner));524			<AccountBalance<T>>::insert((collection.id, owner), account_balance);525526			if let Some(user) = Self::token_owner(collection.id, token) {527				<PalletEvm<T>>::deposit_log(528					ERC721Events::Transfer {529						from: erc::ADDRESS_FOR_PARTIALLY_OWNED_TOKENS,530						to: *user.as_eth(),531						token_id: token.into(),532					}533					.to_log(collection_id_to_address(collection.id)),534				);535			}536		} else {537			<Balance<T>>::insert((collection.id, token, owner), balance);538		}539		<TotalSupply<T>>::insert((collection.id, token), total_supply);540541		<PalletEvm<T>>::deposit_log(542			ERC20Events::Transfer {543				from: *owner.as_eth(),544				to: H160::default(),545				value: amount.into(),546			}547			.to_log(T::EvmTokenAddressMapping::token_to_address(548				collection.id,549				token,550			)),551		);552		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(553			collection.id,554			token,555			owner.clone(),556			amount,557		));558		Ok(())559	}560561	#[transactional]562	fn modify_token_properties(563		collection: &RefungibleHandle<T>,564		sender: &T::CrossAccountId,565		token_id: TokenId,566		properties: impl Iterator<Item = (PropertyKey, Option<PropertyValue>)>,567		is_token_create: bool,568		nesting_budget: &dyn Budget,569	) -> DispatchResult {570		let is_collection_admin = || collection.is_owner_or_admin(sender);571		let is_token_owner = || -> Result<bool, DispatchError> {572			let balance = collection.balance(sender.clone(), token_id);573			let total_pieces: u128 =574				Self::total_pieces(collection.id, token_id).unwrap_or(u128::MAX);575			if balance != total_pieces {576				return Ok(false);577			}578579			let is_bundle_owner = <PalletStructure<T>>::check_indirectly_owned(580				sender.clone(),581				collection.id,582				token_id,583				None,584				nesting_budget,585			)?;586587			Ok(is_bundle_owner)588		};589590		for (key, value) in properties {591			let permission = <PalletCommon<T>>::property_permissions(collection.id)592				.get(&key)593				.cloned()594				.unwrap_or_else(PropertyPermission::none);595596			let is_property_exists = TokenProperties::<T>::get((collection.id, token_id))597				.get(&key)598				.is_some();599600			match permission {601				PropertyPermission { mutable: false, .. } if is_property_exists => {602					return Err(<CommonError<T>>::NoPermission.into());603				}604605				PropertyPermission {606					collection_admin,607					token_owner,608					..609				} => {610					//TODO: investigate threats during public minting.611					let is_token_create =612						is_token_create && (collection_admin || token_owner) && value.is_some();613					if !(is_token_create614						|| (collection_admin && is_collection_admin())615						|| (token_owner && is_token_owner()?))616					{617						fail!(<CommonError<T>>::NoPermission);618					}619				}620			}621622			match value {623				Some(value) => {624					<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {625						properties.try_set(key.clone(), value)626					})627					.map_err(<CommonError<T>>::from)?;628629					<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertySet(630						collection.id,631						token_id,632						key,633					));634				}635				None => {636					<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {637						properties.remove(&key)638					})639					.map_err(<CommonError<T>>::from)?;640641					<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertyDeleted(642						collection.id,643						token_id,644						key,645					));646				}647			}648649			<PalletEvm<T>>::deposit_log(650				CollectionHelpersEvents::TokenChanged {651					collection_id: collection_id_to_address(collection.id),652					token_id: token_id.into(),653				}654				.to_log(T::ContractAddress::get()),655			);656		}657658		Ok(())659	}660661	pub fn set_token_properties(662		collection: &RefungibleHandle<T>,663		sender: &T::CrossAccountId,664		token_id: TokenId,665		properties: impl Iterator<Item = Property>,666		is_token_create: bool,667		nesting_budget: &dyn Budget,668	) -> DispatchResult {669		Self::modify_token_properties(670			collection,671			sender,672			token_id,673			properties.map(|p| (p.key, Some(p.value))),674			is_token_create,675			nesting_budget,676		)677	}678679	pub fn set_token_property(680		collection: &RefungibleHandle<T>,681		sender: &T::CrossAccountId,682		token_id: TokenId,683		property: Property,684		nesting_budget: &dyn Budget,685	) -> DispatchResult {686		let is_token_create = false;687688		Self::set_token_properties(689			collection,690			sender,691			token_id,692			[property].into_iter(),693			is_token_create,694			nesting_budget,695		)696	}697698	pub fn delete_token_properties(699		collection: &RefungibleHandle<T>,700		sender: &T::CrossAccountId,701		token_id: TokenId,702		property_keys: impl Iterator<Item = PropertyKey>,703		nesting_budget: &dyn Budget,704	) -> DispatchResult {705		let is_token_create = false;706707		Self::modify_token_properties(708			collection,709			sender,710			token_id,711			property_keys.into_iter().map(|key| (key, None)),712			is_token_create,713			nesting_budget,714		)715	}716717	pub fn delete_token_property(718		collection: &RefungibleHandle<T>,719		sender: &T::CrossAccountId,720		token_id: TokenId,721		property_key: PropertyKey,722		nesting_budget: &dyn Budget,723	) -> DispatchResult {724		Self::delete_token_properties(725			collection,726			sender,727			token_id,728			[property_key].into_iter(),729			nesting_budget,730		)731	}732733	/// Transfer RFT token pieces from one account to another.734	///735	/// If the sender is no longer owns any pieces after the `transfer` than she stops being an owner of the token.736	///737	/// - `from`: Owner of token pieces to transfer.738	/// - `to`: Recepient of transfered token pieces.739	/// - `amount`: Amount of token pieces to transfer.740	/// - `token`: Token whos pieces should be transfered741	/// - `collection`: Collection that contains the token742	pub fn transfer(743		collection: &RefungibleHandle<T>,744		from: &T::CrossAccountId,745		to: &T::CrossAccountId,746		token: TokenId,747		amount: u128,748		nesting_budget: &dyn Budget,749	) -> DispatchResult {750		ensure!(751			collection.limits.transfers_enabled(),752			<CommonError<T>>::TransferNotAllowed753		);754755		if collection.permissions.access() == AccessMode::AllowList {756			collection.check_allowlist(from)?;757			collection.check_allowlist(to)?;758		}759		<PalletCommon<T>>::ensure_correct_receiver(to)?;760761		let initial_balance_from = <Balance<T>>::get((collection.id, token, from));762763		if initial_balance_from == 0 {764			return Err(<CommonError<T>>::TokenValueTooLow.into());765		}766767		let updated_balance_from = initial_balance_from768			.checked_sub(amount)769			.ok_or(<CommonError<T>>::TokenValueTooLow)?;770		let mut create_target = false;771		let from_to_differ = from != to;772		let updated_balance_to = if from != to && amount != 0 {773			let old_balance = <Balance<T>>::get((collection.id, token, to));774			if old_balance == 0 {775				create_target = true;776			}777			Some(778				old_balance779					.checked_add(amount)780					.ok_or(ArithmeticError::Overflow)?,781			)782		} else {783			None784		};785786		let account_balance_from = if updated_balance_from == 0 {787			Some(788				<AccountBalance<T>>::get((collection.id, from))789					.checked_sub(1)790					// Should not occur791					.ok_or(ArithmeticError::Underflow)?,792			)793		} else {794			None795		};796		// Account data is created in token, AccountBalance should be increased797		// But only if from != to as we shouldn't check overflow in this case798		let account_balance_to = if create_target && from_to_differ {799			let account_balance_to = <AccountBalance<T>>::get((collection.id, to))800				.checked_add(1)801				.ok_or(ArithmeticError::Overflow)?;802			ensure!(803				account_balance_to < collection.limits.account_token_ownership_limit(),804				<CommonError<T>>::AccountTokenLimitExceeded,805			);806807			Some(account_balance_to)808		} else {809			None810		};811812		// =========813814		if let Some(updated_balance_to) = updated_balance_to {815			// from != to && amount != 0816817			<PalletStructure<T>>::nest_if_sent_to_token(818				from.clone(),819				to,820				collection.id,821				token,822				nesting_budget,823			)?;824825			if updated_balance_from == 0 {826				<Balance<T>>::remove((collection.id, token, from));827				<PalletStructure<T>>::unnest_if_nested(from, collection.id, token);828			} else {829				<Balance<T>>::insert((collection.id, token, from), updated_balance_from);830			}831			<Balance<T>>::insert((collection.id, token, to), updated_balance_to);832			if let Some(account_balance_from) = account_balance_from {833				<AccountBalance<T>>::insert((collection.id, from), account_balance_from);834				<Owned<T>>::remove((collection.id, from, token));835			}836			if let Some(account_balance_to) = account_balance_to {837				<AccountBalance<T>>::insert((collection.id, to), account_balance_to);838				<Owned<T>>::insert((collection.id, to, token), true);839			}840		}841842		<PalletEvm<T>>::deposit_log(843			ERC20Events::Transfer {844				from: *from.as_eth(),845				to: *to.as_eth(),846				value: amount.into(),847			}848			.to_log(T::EvmTokenAddressMapping::token_to_address(849				collection.id,850				token,851			)),852		);853854		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(855			collection.id,856			token,857			from.clone(),858			to.clone(),859			amount,860		));861862		let total_supply = <TotalSupply<T>>::get((collection.id, token));863864		if amount == total_supply {865			// if token was fully owned by `from` and will be fully owned by `to` after transfer866			<PalletEvm<T>>::deposit_log(867				ERC721Events::Transfer {868					from: *from.as_eth(),869					to: *to.as_eth(),870					token_id: token.into(),871				}872				.to_log(collection_id_to_address(collection.id)),873			);874		} else if let Some(updated_balance_to) = updated_balance_to {875			// if `from` not equals `to`. This condition is needed to avoid sending event876			// when `from` fully owns token and sends part of token pieces to itself.877			if initial_balance_from == total_supply {878				// if token was fully owned by `from` and will be only partially owned by `to`879				// and `from` after transfer880				<PalletEvm<T>>::deposit_log(881					ERC721Events::Transfer {882						from: *from.as_eth(),883						to: erc::ADDRESS_FOR_PARTIALLY_OWNED_TOKENS,884						token_id: token.into(),885					}886					.to_log(collection_id_to_address(collection.id)),887				);888			} else if updated_balance_to == total_supply {889				// if token was partially owned by `from` and will be fully owned by `to` after transfer890				<PalletEvm<T>>::deposit_log(891					ERC721Events::Transfer {892						from: erc::ADDRESS_FOR_PARTIALLY_OWNED_TOKENS,893						to: *to.as_eth(),894						token_id: token.into(),895					}896					.to_log(collection_id_to_address(collection.id)),897				);898			}899		}900901		Ok(())902	}903904	/// Batched operation to create multiple RFT tokens.905	///906	/// Same as `create_item` but creates multiple tokens.907	///908	/// - `data`: Same as 'data` in `create_item` but contains data for multiple tokens.909	pub fn create_multiple_items(910		collection: &RefungibleHandle<T>,911		sender: &T::CrossAccountId,912		data: Vec<CreateItemData<T>>,913		nesting_budget: &dyn Budget,914	) -> DispatchResult {915		if !collection.is_owner_or_admin(sender) {916			ensure!(917				collection.permissions.mint_mode(),918				<CommonError<T>>::PublicMintingNotAllowed919			);920			collection.check_allowlist(sender)?;921922			for item in data.iter() {923				for user in item.users.keys() {924					collection.check_allowlist(user)?;925				}926			}927		}928929		for item in data.iter() {930			for (owner, _) in item.users.iter() {931				<PalletCommon<T>>::ensure_correct_receiver(owner)?;932			}933		}934935		// Total pieces per tokens936		let totals = data937			.iter()938			.map(|data| {939				Ok(data940					.users941					.iter()942					.map(|u| u.1)943					.try_fold(0u128, |acc, v| acc.checked_add(*v))944					.ok_or(ArithmeticError::Overflow)?)945			})946			.collect::<Result<Vec<_>, DispatchError>>()?;947		for total in &totals {948			ensure!(949				*total <= MAX_REFUNGIBLE_PIECES,950				<Error<T>>::WrongRefungiblePieces951			);952		}953954		let first_token_id = <TokensMinted<T>>::get(collection.id);955		let tokens_minted = first_token_id956			.checked_add(data.len() as u32)957			.ok_or(ArithmeticError::Overflow)?;958		ensure!(959			tokens_minted < collection.limits.token_limit(),960			<CommonError<T>>::CollectionTokenLimitExceeded961		);962963		let mut balances = BTreeMap::new();964		for data in &data {965			for owner in data.users.keys() {966				let balance = balances967					.entry(owner)968					.or_insert_with(|| <AccountBalance<T>>::get((collection.id, owner)));969				*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;970971				ensure!(972					*balance <= collection.limits.account_token_ownership_limit(),973					<CommonError<T>>::AccountTokenLimitExceeded,974				);975			}976		}977978		for (i, token) in data.iter().enumerate() {979			let token_id = TokenId(first_token_id + i as u32 + 1);980			for (to, _) in token.users.iter() {981				<PalletStructure<T>>::check_nesting(982					sender.clone(),983					to,984					collection.id,985					token_id,986					nesting_budget,987				)?;988			}989		}990991		// =========992993		with_transaction(|| {994			for (i, data) in data.iter().enumerate() {995				let token_id = first_token_id + i as u32 + 1;996				<TotalSupply<T>>::insert((collection.id, token_id), totals[i]);997998				for (user, amount) in data.users.iter() {999					if *amount == 0 {1000						continue;1001					}1002					<Balance<T>>::insert((collection.id, token_id, &user), amount);1003					<Owned<T>>::insert((collection.id, &user, TokenId(token_id)), true);1004					<PalletStructure<T>>::nest_if_sent_to_token_unchecked(1005						user,1006						collection.id,1007						TokenId(token_id),1008					);1009				}10101011				if let Err(e) = Self::set_token_properties(1012					collection,1013					sender,1014					TokenId(token_id),1015					data.properties.clone().into_iter(),1016					true,1017					nesting_budget,1018				) {1019					return TransactionOutcome::Rollback(Err(e));1020				}1021			}1022			TransactionOutcome::Commit(Ok(()))1023		})?;10241025		<TokensMinted<T>>::insert(collection.id, tokens_minted);10261027		for (account, balance) in balances {1028			<AccountBalance<T>>::insert((collection.id, account), balance);1029		}10301031		for (i, token) in data.into_iter().enumerate() {1032			let token_id = first_token_id + i as u32 + 1;10331034			let receivers = token1035				.users1036				.into_iter()1037				.filter(|(_, amount)| *amount > 0)1038				.collect::<Vec<_>>();10391040			if let [(user, _)] = receivers.as_slice() {1041				// if there is exactly one receiver1042				<PalletEvm<T>>::deposit_log(1043					ERC721Events::Transfer {1044						from: H160::default(),1045						to: *user.as_eth(),1046						token_id: token_id.into(),1047					}1048					.to_log(collection_id_to_address(collection.id)),1049				);1050			} else if let [_, ..] = receivers.as_slice() {1051				// if there is more than one receiver1052				<PalletEvm<T>>::deposit_log(1053					ERC721Events::Transfer {1054						from: H160::default(),1055						to: erc::ADDRESS_FOR_PARTIALLY_OWNED_TOKENS,1056						token_id: token_id.into(),1057					}1058					.to_log(collection_id_to_address(collection.id)),1059				);1060			}10611062			for (user, amount) in receivers.into_iter() {1063				<PalletEvm<T>>::deposit_log(1064					ERC20Events::Transfer {1065						from: H160::default(),1066						to: *user.as_eth(),1067						value: amount.into(),1068					}1069					.to_log(T::EvmTokenAddressMapping::token_to_address(1070						collection.id,1071						TokenId(token_id),1072					)),1073				);1074				<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(1075					collection.id,1076					TokenId(token_id),1077					user,1078					amount,1079				));1080			}1081		}1082		Ok(())1083	}10841085	pub fn set_allowance_unchecked(1086		collection: &RefungibleHandle<T>,1087		sender: &T::CrossAccountId,1088		spender: &T::CrossAccountId,1089		token: TokenId,1090		amount: u128,1091	) {1092		if amount == 0 {1093			<Allowance<T>>::remove((collection.id, token, sender, spender));1094		} else {1095			<Allowance<T>>::insert((collection.id, token, sender, spender), amount);1096		}10971098		<PalletEvm<T>>::deposit_log(1099			ERC20Events::Approval {1100				owner: *sender.as_eth(),1101				spender: *spender.as_eth(),1102				value: amount.into(),1103			}1104			.to_log(T::EvmTokenAddressMapping::token_to_address(1105				collection.id,1106				token,1107			)),1108		);1109		<PalletCommon<T>>::deposit_event(CommonEvent::Approved(1110			collection.id,1111			token,1112			sender.clone(),1113			spender.clone(),1114			amount,1115		))1116	}11171118	/// Set allowance for the spender to `transfer` or `burn` sender's token pieces.1119	///1120	/// - `amount`: Amount of token pieces the spender is allowed to `transfer` or `burn.1121	pub fn set_allowance(1122		collection: &RefungibleHandle<T>,1123		sender: &T::CrossAccountId,1124		spender: &T::CrossAccountId,1125		token: TokenId,1126		amount: u128,1127	) -> DispatchResult {1128		if collection.permissions.access() == AccessMode::AllowList {1129			collection.check_allowlist(sender)?;1130			collection.check_allowlist(spender)?;1131		}11321133		<PalletCommon<T>>::ensure_correct_receiver(spender)?;11341135		if <Balance<T>>::get((collection.id, token, sender)) < amount {1136			ensure!(1137				collection.ignores_owned_amount(sender) && Self::token_exists(collection, token),1138				<CommonError<T>>::CantApproveMoreThanOwned1139			);1140		}11411142		// =========11431144		Self::set_allowance_unchecked(collection, sender, spender, token, amount);1145		Ok(())1146	}11471148	/// Returns allowance, which should be set after transaction1149	fn check_allowed(1150		collection: &RefungibleHandle<T>,1151		spender: &T::CrossAccountId,1152		from: &T::CrossAccountId,1153		token: TokenId,1154		amount: u128,1155		nesting_budget: &dyn Budget,1156	) -> Result<Option<u128>, DispatchError> {1157		if spender.conv_eq(from) {1158			return Ok(None);1159		}1160		if collection.permissions.access() == AccessMode::AllowList {1161			// `from`, `to` checked in [`transfer`]1162			collection.check_allowlist(spender)?;1163		}1164		if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {1165			// TODO: should collection owner be allowed to perform this transfer?1166			ensure!(1167				<PalletStructure<T>>::check_indirectly_owned(1168					spender.clone(),1169					source.0,1170					source.1,1171					None,1172					nesting_budget1173				)?,1174				<CommonError<T>>::ApprovedValueTooLow,1175			);1176			return Ok(None);1177		}1178		let allowance =1179			<Allowance<T>>::get((collection.id, token, from, &spender)).checked_sub(amount);11801181		// Allowance (if any) would be reduced if spender is also wallet operator1182		if <CollectionAllowance<T>>::get((collection.id, from, spender)) {1183			return Ok(allowance);1184		}11851186		if allowance.is_none() {1187			ensure!(1188				collection.ignores_allowance(spender),1189				<CommonError<T>>::ApprovedValueTooLow1190			);1191		}1192		Ok(allowance)1193	}11941195	/// Transfer RFT token pieces from one account to another.1196	///1197	/// Same as the [`transfer`] but spender doesn't needs to be an owner of the token pieces.1198	/// The owner should set allowance for the spender to transfer pieces.1199	///1200	/// [`transfer`]: struct.Pallet.html#method.transfer1201	pub fn transfer_from(1202		collection: &RefungibleHandle<T>,1203		spender: &T::CrossAccountId,1204		from: &T::CrossAccountId,1205		to: &T::CrossAccountId,1206		token: TokenId,1207		amount: u128,1208		nesting_budget: &dyn Budget,1209	) -> DispatchResult {1210		let allowance =1211			Self::check_allowed(collection, spender, from, token, amount, nesting_budget)?;12121213		// =========12141215		Self::transfer(collection, from, to, token, amount, nesting_budget)?;1216		if let Some(allowance) = allowance {1217			Self::set_allowance_unchecked(collection, from, spender, token, allowance);1218		}1219		Ok(())1220	}12211222	/// Burn RFT token pieces from the account.1223	///1224	/// Same as the [`burn`] but spender doesn't need to be an owner of the token pieces. The owner should1225	/// set allowance for the spender to burn pieces1226	///1227	/// [`burn`]: struct.Pallet.html#method.burn1228	pub fn burn_from(1229		collection: &RefungibleHandle<T>,1230		spender: &T::CrossAccountId,1231		from: &T::CrossAccountId,1232		token: TokenId,1233		amount: u128,1234		nesting_budget: &dyn Budget,1235	) -> DispatchResult {1236		let allowance =1237			Self::check_allowed(collection, spender, from, token, amount, nesting_budget)?;12381239		// =========12401241		Self::burn(collection, from, token, amount)?;1242		if let Some(allowance) = allowance {1243			Self::set_allowance_unchecked(collection, from, spender, token, allowance);1244		}1245		Ok(())1246	}12471248	/// Create RFT token.1249	///1250	/// The sender should be the owner/admin of the collection or collection should be configured1251	/// to allow public minting.1252	///1253	/// - `data`: Contains list of users who will become the owners of the token pieces and amount1254	///   of token pieces they will receive.1255	pub fn create_item(1256		collection: &RefungibleHandle<T>,1257		sender: &T::CrossAccountId,1258		data: CreateItemData<T>,1259		nesting_budget: &dyn Budget,1260	) -> DispatchResult {1261		Self::create_multiple_items(collection, sender, vec![data], nesting_budget)1262	}12631264	/// Repartition RFT token.1265	///1266	/// `repartition` will set token balance of the sender and total amount of token pieces.1267	/// Sender should own all of the token pieces. `repartition' could be done even if some1268	/// token pieces were burned before.1269	///1270	/// - `amount`: Total amount of token pieces that the token will have after `repartition`.1271	pub fn repartition(1272		collection: &RefungibleHandle<T>,1273		owner: &T::CrossAccountId,1274		token: TokenId,1275		amount: u128,1276	) -> DispatchResult {1277		ensure!(1278			amount <= MAX_REFUNGIBLE_PIECES,1279			<Error<T>>::WrongRefungiblePieces1280		);1281		ensure!(amount > 0, <CommonError<T>>::TokenValueTooLow);1282		// Ensure user owns all pieces1283		let total_pieces = Self::total_pieces(collection.id, token).unwrap_or(u128::MAX);1284		let balance = <Balance<T>>::get((collection.id, token, owner));1285		ensure!(1286			total_pieces == balance,1287			<Error<T>>::RepartitionWhileNotOwningAllPieces1288		);12891290		<Balance<T>>::insert((collection.id, token, owner), amount);1291		<TotalSupply<T>>::insert((collection.id, token), amount);12921293		if amount > total_pieces {1294			let mint_amount = amount - total_pieces;1295			<PalletEvm<T>>::deposit_log(1296				ERC20Events::Transfer {1297					from: H160::default(),1298					to: *owner.as_eth(),1299					value: mint_amount.into(),1300				}1301				.to_log(T::EvmTokenAddressMapping::token_to_address(1302					collection.id,1303					token,1304				)),1305			);1306			<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(1307				collection.id,1308				token,1309				owner.clone(),1310				mint_amount,1311			));1312		} else if total_pieces > amount {1313			let burn_amount = total_pieces - amount;1314			<PalletEvm<T>>::deposit_log(1315				ERC20Events::Transfer {1316					from: *owner.as_eth(),1317					to: H160::default(),1318					value: burn_amount.into(),1319				}1320				.to_log(T::EvmTokenAddressMapping::token_to_address(1321					collection.id,1322					token,1323				)),1324			);1325			<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(1326				collection.id,1327				token,1328				owner.clone(),1329				burn_amount,1330			));1331		}13321333		Ok(())1334	}13351336	fn token_owner(collection_id: CollectionId, token_id: TokenId) -> Option<T::CrossAccountId> {1337		let mut owner = None;1338		let mut count = 0;1339		for key in Balance::<T>::iter_key_prefix((collection_id, token_id)) {1340			count += 1;1341			if count > 1 {1342				return None;1343			}1344			owner = Some(key);1345		}1346		owner1347	}13481349	fn total_pieces(collection_id: CollectionId, token_id: TokenId) -> Option<u128> {1350		<TotalSupply<T>>::try_get((collection_id, token_id)).ok()1351	}13521353	pub fn set_collection_properties(1354		collection: &RefungibleHandle<T>,1355		sender: &T::CrossAccountId,1356		properties: Vec<Property>,1357	) -> DispatchResult {1358		<PalletCommon<T>>::set_collection_properties(collection, sender, properties)1359	}13601361	pub fn delete_collection_properties(1362		collection: &RefungibleHandle<T>,1363		sender: &T::CrossAccountId,1364		property_keys: Vec<PropertyKey>,1365	) -> DispatchResult {1366		<PalletCommon<T>>::delete_collection_properties(collection, sender, property_keys)1367	}13681369	pub fn set_token_property_permissions(1370		collection: &RefungibleHandle<T>,1371		sender: &T::CrossAccountId,1372		property_permissions: Vec<PropertyKeyPermission>,1373	) -> DispatchResult {1374		<PalletCommon<T>>::set_token_property_permissions(collection, sender, property_permissions)1375	}13761377	pub fn token_property_permission(collection_id: CollectionId) -> PropertiesPermissionMap {1378		<PalletCommon<T>>::property_permissions(collection_id)1379	}13801381	pub fn set_scoped_token_property_permissions(1382		collection: &RefungibleHandle<T>,1383		sender: &T::CrossAccountId,1384		scope: PropertyScope,1385		property_permissions: Vec<PropertyKeyPermission>,1386	) -> DispatchResult {1387		<PalletCommon<T>>::set_scoped_token_property_permissions(1388			collection,1389			sender,1390			scope,1391			property_permissions,1392		)1393	}13941395	/// Returns 10 token in no particular order.1396	///1397	/// There is no direct way to get token holders in ascending order,1398	/// since `iter_prefix` returns values in no particular order.1399	/// Therefore, getting the 10 largest holders with a large value of holders1400	/// can lead to impact memory allocation + sorting with  `n * log (n)`.1401	pub fn token_owners(1402		collection_id: CollectionId,1403		token: TokenId,1404	) -> Option<Vec<T::CrossAccountId>> {1405		let res: Vec<T::CrossAccountId> = <Balance<T>>::iter_prefix((collection_id, token))1406			.map(|(owner, _amount)| owner)1407			.take(10)1408			.collect();14091410		if res.is_empty() {1411			None1412		} else {1413			Some(res)1414		}1415	}14161417	/// Sets or unsets the approval of a given operator.1418	///1419	/// The `operator` is allowed to transfer all token pieces of the `owner` on their behalf.1420	/// - `owner`: Token owner1421	/// - `operator`: Operator1422	/// - `approve`: Should operator status be granted or revoked?1423	pub fn set_allowance_for_all(1424		collection: &RefungibleHandle<T>,1425		owner: &T::CrossAccountId,1426		operator: &T::CrossAccountId,1427		approve: bool,1428	) -> DispatchResult {1429		if collection.permissions.access() == AccessMode::AllowList {1430			collection.check_allowlist(owner)?;1431			collection.check_allowlist(operator)?;1432		}14331434		<PalletCommon<T>>::ensure_correct_receiver(operator)?;14351436		// =========14371438		<CollectionAllowance<T>>::insert((collection.id, owner, operator), approve);1439		<PalletEvm<T>>::deposit_log(1440			ERC721Events::ApprovalForAll {1441				owner: *owner.as_eth(),1442				operator: *operator.as_eth(),1443				approved: approve,1444			}1445			.to_log(collection_id_to_address(collection.id)),1446		);1447		<PalletCommon<T>>::deposit_event(CommonEvent::ApprovedForAll(1448			collection.id,1449			owner.clone(),1450			operator.clone(),1451			approve,1452		));1453		Ok(())1454	}14551456	/// Tells whether the given `owner` approves the `operator`.1457	pub fn allowance_for_all(1458		collection: &RefungibleHandle<T>,1459		owner: &T::CrossAccountId,1460		operator: &T::CrossAccountId,1461	) -> bool {1462		<CollectionAllowance<T>>::get((collection.id, owner, operator))1463	}14641465	pub fn repair_item(collection: &RefungibleHandle<T>, token: TokenId) -> DispatchResult {1466		<TokenProperties<T>>::mutate((collection.id, token), |properties| {1467			properties.recompute_consumed_space();1468		});14691470		Ok(())1471	}1472}