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

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 Pallet EVM API for tokens18//!19//! Provides ERC-721 standart support implementation and EVM API for unique extensions for Refungible Pallet.20//! Method implementations are mostly doing parameter conversion and calling Refungible Pallet methods.2122extern crate alloc;2324use core::{25	char::{REPLACEMENT_CHARACTER, decode_utf16},26	convert::TryInto,27};28use evm_coder::{29	abi::AbiType, ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*,30	types::Property as PropertyStruct, weight,31};32use frame_support::{BoundedBTreeMap, BoundedVec};33use pallet_common::{34	CollectionHandle, CollectionPropertyPermissions,35	erc::{CommonEvmHandler, CollectionCall, static_property::key},36	eth::EthCrossAccount,37	CommonCollectionOperations,38};39use pallet_evm::{account::CrossAccountId, PrecompileHandle};40use pallet_evm_coder_substrate::{call, dispatch_to_evm};41use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};42use sp_core::{H160, Get};43use sp_std::{collections::btree_map::BTreeMap, vec::Vec, vec};44use up_data_structs::{45	CollectionId, CollectionPropertiesVec, mapping::TokenAddressMapping, Property, PropertyKey,46	PropertyKeyPermission, PropertyPermission, TokenId,47};4849use crate::{50	AccountBalance, Balance, Config, CreateItemData, Pallet, RefungibleHandle, SelfWeightOf,51	TokenProperties, TokensMinted, TotalSupply, weights::WeightInfo,52};5354pub const ADDRESS_FOR_PARTIALLY_OWNED_TOKENS: H160 = H160::repeat_byte(0xff);5556/// @title A contract that allows to set and delete token properties and change token property permissions.57#[solidity_interface(name = TokenProperties)]58impl<T: Config> RefungibleHandle<T> {59	/// @notice Set permissions for token property.60	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.61	/// @param key Property key.62	/// @param isMutable Permission to mutate property.63	/// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.64	/// @param tokenOwner Permission to mutate property by token owner if property is mutable.65	fn set_token_property_permission(66		&mut self,67		caller: caller,68		key: string,69		is_mutable: bool,70		collection_admin: bool,71		token_owner: bool,72	) -> Result<()> {73		let caller = T::CrossAccountId::from_eth(caller);74		<Pallet<T>>::set_token_property_permissions(75			self,76			&caller,77			vec![PropertyKeyPermission {78				key: <Vec<u8>>::from(key)79					.try_into()80					.map_err(|_| "too long key")?,81				permission: PropertyPermission {82					mutable: is_mutable,83					collection_admin,84					token_owner,85				},86			}],87		)88		.map_err(dispatch_to_evm::<T>)89	}9091	/// @notice Set token property value.92	/// @dev Throws error if `msg.sender` has no permission to edit the property.93	/// @param tokenId ID of the token.94	/// @param key Property key.95	/// @param value Property value.96	#[solidity(hide)]97	fn set_property(98		&mut self,99		caller: caller,100		token_id: uint256,101		key: string,102		value: bytes,103	) -> Result<()> {104		let caller = T::CrossAccountId::from_eth(caller);105		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;106		let key = <Vec<u8>>::from(key)107			.try_into()108			.map_err(|_| "key too long")?;109		let value = value.0.try_into().map_err(|_| "value too long")?;110111		let nesting_budget = self112			.recorder113			.weight_calls_budget(<StructureWeight<T>>::find_parent());114115		<Pallet<T>>::set_token_property(116			self,117			&caller,118			TokenId(token_id),119			Property { key, value },120			&nesting_budget,121		)122		.map_err(dispatch_to_evm::<T>)123	}124125	/// @notice Set token properties value.126	/// @dev Throws error if `msg.sender` has no permission to edit the property.127	/// @param tokenId ID of the token.128	/// @param properties settable properties129	fn set_properties(130		&mut self,131		caller: caller,132		token_id: uint256,133		properties: Vec<PropertyStruct>,134	) -> Result<()> {135		let caller = T::CrossAccountId::from_eth(caller);136		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;137138		let nesting_budget = self139			.recorder140			.weight_calls_budget(<StructureWeight<T>>::find_parent());141142		let properties = properties143			.into_iter()144			.map(|PropertyStruct { key, value }| {145				let key = <Vec<u8>>::from(key)146					.try_into()147					.map_err(|_| "key too large")?;148149				let value = value.0.try_into().map_err(|_| "value too large")?;150151				Ok(Property { key, value })152			})153			.collect::<Result<Vec<_>>>()?;154155		<Pallet<T>>::set_token_properties(156			self,157			&caller,158			TokenId(token_id),159			properties.into_iter(),160			<Pallet<T>>::token_exists(&self, TokenId(token_id)),161			&nesting_budget,162		)163		.map_err(dispatch_to_evm::<T>)164	}165166	/// @notice Delete token property value.167	/// @dev Throws error if `msg.sender` has no permission to edit the property.168	/// @param tokenId ID of the token.169	/// @param key Property key.170	#[solidity(hide)]171	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {172		let caller = T::CrossAccountId::from_eth(caller);173		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;174		let key = <Vec<u8>>::from(key)175			.try_into()176			.map_err(|_| "key too long")?;177178		let nesting_budget = self179			.recorder180			.weight_calls_budget(<StructureWeight<T>>::find_parent());181182		<Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)183			.map_err(dispatch_to_evm::<T>)184	}185186	/// @notice Delete token properties value.187	/// @dev Throws error if `msg.sender` has no permission to edit the property.188	/// @param tokenId ID of the token.189	/// @param keys Properties key.190	fn delete_properties(191		&mut self,192		token_id: uint256,193		caller: caller,194		keys: Vec<string>,195	) -> Result<()> {196		let caller = T::CrossAccountId::from_eth(caller);197		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;198		let keys = keys199			.into_iter()200			.map(|k| Ok(<Vec<u8>>::from(k).try_into().map_err(|_| "key too long")?))201			.collect::<Result<Vec<_>>>()?;202203		let nesting_budget = self204			.recorder205			.weight_calls_budget(<StructureWeight<T>>::find_parent());206207		<Pallet<T>>::delete_token_properties(208			self,209			&caller,210			TokenId(token_id),211			keys.into_iter(),212			&nesting_budget,213		)214		.map_err(dispatch_to_evm::<T>)215	}216217	/// @notice Get token property value.218	/// @dev Throws error if key not found219	/// @param tokenId ID of the token.220	/// @param key Property key.221	/// @return Property value bytes222	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {223		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;224		let key = <Vec<u8>>::from(key)225			.try_into()226			.map_err(|_| "key too long")?;227228		let props = <TokenProperties<T>>::get((self.id, token_id));229		let prop = props.get(&key).ok_or("key not found")?;230231		Ok(prop.to_vec().into())232	}233}234235#[derive(ToLog)]236pub enum ERC721Events {237	/// @dev This event emits when NFTs are created (`from` == 0) and destroyed238	///  (`to` == 0). Exception: during contract creation, any number of RFTs239	///  may be created and assigned without emitting Transfer.240	Transfer {241		#[indexed]242		from: address,243		#[indexed]244		to: address,245		#[indexed]246		token_id: uint256,247	},248	/// @dev Not supported249	Approval {250		#[indexed]251		owner: address,252		#[indexed]253		approved: address,254		#[indexed]255		token_id: uint256,256	},257	/// @dev Not supported258	#[allow(dead_code)]259	ApprovalForAll {260		#[indexed]261		owner: address,262		#[indexed]263		operator: address,264		approved: bool,265	},266}267268#[derive(ToLog)]269pub enum ERC721UniqueMintableEvents {270	/// @dev Not supported271	#[allow(dead_code)]272	MintingFinished {},273}274275#[solidity_interface(name = ERC721Metadata)]276impl<T: Config> RefungibleHandle<T>277where278	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,279{280	/// @notice A descriptive name for a collection of NFTs in this contract281	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`282	#[solidity(hide, rename_selector = "name")]283	fn name_proxy(&self) -> Result<string> {284		self.name()285	}286287	/// @notice An abbreviated name for NFTs in this contract288	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`289	#[solidity(hide, rename_selector = "symbol")]290	fn symbol_proxy(&self) -> Result<string> {291		self.symbol()292	}293294	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.295	///296	/// @dev If the token has a `url` property and it is not empty, it is returned.297	///  Else If the collection does not have a property with key `schemaName` or its value is not equal to `ERC721Metadata`, it return an error `tokenURI not set`.298	///  If the collection property `baseURI` is empty or absent, return "" (empty string)299	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix300	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).301	///302	/// @return token's const_metadata303	#[solidity(rename_selector = "tokenURI")]304	fn token_uri(&self, token_id: uint256) -> Result<string> {305		let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;306307		match get_token_property(self, token_id_u32, &key::url()).as_deref() {308			Err(_) | Ok("") => (),309			Ok(url) => {310				return Ok(url.into());311			}312		};313314		let base_uri =315			pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())316				.map(BoundedVec::into_inner)317				.map(string::from_utf8)318				.transpose()319				.map_err(|e| {320					Error::Revert(alloc::format!(321						"Can not convert value \"baseURI\" to string with error \"{}\"",322						e323					))324				})?;325326		let base_uri = match base_uri.as_deref() {327			None | Some("") => {328				return Ok("".into());329			}330			Some(base_uri) => base_uri.into(),331		};332333		Ok(334			match get_token_property(self, token_id_u32, &key::suffix()).as_deref() {335				Err(_) | Ok("") => base_uri,336				Ok(suffix) => base_uri + suffix,337			},338		)339	}340}341342/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension343/// @dev See https://eips.ethereum.org/EIPS/eip-721344#[solidity_interface(name = ERC721Enumerable)]345impl<T: Config> RefungibleHandle<T> {346	/// @notice Enumerate valid RFTs347	/// @param index A counter less than `totalSupply()`348	/// @return The token identifier for the `index`th NFT,349	///  (sort order not specified)350	fn token_by_index(&self, index: uint256) -> Result<uint256> {351		Ok(index)352	}353354	/// Not implemented355	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {356		// TODO: Not implemetable357		Err("not implemented".into())358	}359360	/// @notice Count RFTs tracked by this contract361	/// @return A count of valid RFTs tracked by this contract, where each one of362	///  them has an assigned and queryable owner not equal to the zero address363	fn total_supply(&self) -> Result<uint256> {364		self.consume_store_reads(1)?;365		Ok(<Pallet<T>>::total_supply(self).into())366	}367}368369/// @title ERC-721 Non-Fungible Token Standard370/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md371#[solidity_interface(name = ERC721, events(ERC721Events))]372impl<T: Config> RefungibleHandle<T> {373	/// @notice Count all RFTs assigned to an owner374	/// @dev RFTs assigned to the zero address are considered invalid, and this375	///  function throws for queries about the zero address.376	/// @param owner An address for whom to query the balance377	/// @return The number of RFTs owned by `owner`, possibly zero378	fn balance_of(&self, owner: address) -> Result<uint256> {379		self.consume_store_reads(1)?;380		let owner = T::CrossAccountId::from_eth(owner);381		let balance = <AccountBalance<T>>::get((self.id, owner));382		Ok(balance.into())383	}384385	/// @notice Find the owner of an RFT386	/// @dev RFTs assigned to zero address are considered invalid, and queries387	///  about them do throw.388	///  Returns special 0xffffffffffffffffffffffffffffffffffffffff address for389	///  the tokens that are partially owned.390	/// @param tokenId The identifier for an RFT391	/// @return The address of the owner of the RFT392	fn owner_of(&self, token_id: uint256) -> Result<address> {393		self.consume_store_reads(2)?;394		let token = token_id.try_into()?;395		let owner = <Pallet<T>>::token_owner(self.id, token);396		Ok(owner397			.map(|address| *address.as_eth())398			.unwrap_or_else(|| ADDRESS_FOR_PARTIALLY_OWNED_TOKENS))399	}400401	/// @dev Not implemented402	fn safe_transfer_from_with_data(403		&mut self,404		_from: address,405		_to: address,406		_token_id: uint256,407		_data: bytes,408	) -> Result<void> {409		// TODO: Not implemetable410		Err("not implemented".into())411	}412413	/// @dev Not implemented414	fn safe_transfer_from(415		&mut self,416		_from: address,417		_to: address,418		_token_id: uint256,419	) -> Result<void> {420		// TODO: Not implemetable421		Err("not implemented".into())422	}423424	/// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE425	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE426	///  THEY MAY BE PERMANENTLY LOST427	/// @dev Throws unless `msg.sender` is the current owner or an authorized428	///  operator for this RFT. Throws if `from` is not the current owner. Throws429	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.430	///  Throws if RFT pieces have multiple owners.431	/// @param from The current owner of the NFT432	/// @param to The new owner433	/// @param tokenId The NFT to transfer434	#[weight(<SelfWeightOf<T>>::transfer_from_creating_removing())]435	fn transfer_from(436		&mut self,437		caller: caller,438		from: address,439		to: address,440		token_id: uint256,441	) -> Result<void> {442		let caller = T::CrossAccountId::from_eth(caller);443		let from = T::CrossAccountId::from_eth(from);444		let to = T::CrossAccountId::from_eth(to);445		let token = token_id.try_into()?;446		let budget = self447			.recorder448			.weight_calls_budget(<StructureWeight<T>>::find_parent());449450		let balance = balance(&self, token, &from)?;451		ensure_single_owner(&self, token, balance)?;452453		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token, balance, &budget)454			.map_err(dispatch_to_evm::<T>)?;455456		Ok(())457	}458459	/// @dev Not implemented460	fn approve(&mut self, _caller: caller, _approved: address, _token_id: uint256) -> Result<void> {461		Err("not implemented".into())462	}463464	/// @dev Not implemented465	fn set_approval_for_all(466		&mut self,467		_caller: caller,468		_operator: address,469		_approved: bool,470	) -> Result<void> {471		// TODO: Not implemetable472		Err("not implemented".into())473	}474475	/// @dev Not implemented476	fn get_approved(&self, _token_id: uint256) -> Result<address> {477		// TODO: Not implemetable478		Err("not implemented".into())479	}480481	/// @dev Not implemented482	fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {483		// TODO: Not implemetable484		Err("not implemented".into())485	}486487	/// @notice Returns collection helper contract address488	fn collection_helper_address(&self) -> Result<address> {489		Ok(T::ContractAddress::get())490	}491}492493/// Returns amount of pieces of `token` that `owner` have494pub fn balance<T: Config>(495	collection: &RefungibleHandle<T>,496	token: TokenId,497	owner: &T::CrossAccountId,498) -> Result<u128> {499	collection.consume_store_reads(1)?;500	let balance = <Balance<T>>::get((collection.id, token, &owner));501	Ok(balance)502}503504/// Throws if `owner_balance` is lower than total amount of `token` pieces505pub fn ensure_single_owner<T: Config>(506	collection: &RefungibleHandle<T>,507	token: TokenId,508	owner_balance: u128,509) -> Result<()> {510	collection.consume_store_reads(1)?;511	let total_supply = <TotalSupply<T>>::get((collection.id, token));512	if total_supply != owner_balance {513		return Err("token has multiple owners".into());514	}515	Ok(())516}517518/// @title ERC721 Token that can be irreversibly burned (destroyed).519#[solidity_interface(name = ERC721Burnable)]520impl<T: Config> RefungibleHandle<T> {521	/// @notice Burns a specific ERC721 token.522	/// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized523	///  operator of the current owner.524	/// @param tokenId The RFT to approve525	#[weight(<SelfWeightOf<T>>::burn_item_fully())]526	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {527		let caller = T::CrossAccountId::from_eth(caller);528		let token = token_id.try_into()?;529530		let balance = balance(&self, token, &caller)?;531		ensure_single_owner(&self, token, balance)?;532533		<Pallet<T>>::burn(self, &caller, token, balance).map_err(dispatch_to_evm::<T>)?;534		Ok(())535	}536}537538/// @title ERC721 minting logic.539#[solidity_interface(name = ERC721UniqueMintable, events(ERC721UniqueMintableEvents))]540impl<T: Config> RefungibleHandle<T> {541	fn minting_finished(&self) -> Result<bool> {542		Ok(false)543	}544545	/// @notice Function to mint token.546	/// @param to The new owner547	/// @return uint256 The id of the newly minted token548	#[weight(<SelfWeightOf<T>>::create_item())]549	fn mint(&mut self, caller: caller, to: address) -> Result<uint256> {550		let token_id: uint256 = <TokensMinted<T>>::get(self.id)551			.checked_add(1)552			.ok_or("item id overflow")?553			.into();554		self.mint_check_id(caller, to, token_id)?;555		Ok(token_id)556	}557558	/// @notice Function to mint token.559	/// @dev `tokenId` should be obtained with `nextTokenId` method,560	///  unlike standard, you can't specify it manually561	/// @param to The new owner562	/// @param tokenId ID of the minted RFT563	#[solidity(hide, rename_selector = "mint")]564	#[weight(<SelfWeightOf<T>>::create_item())]565	fn mint_check_id(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {566		let caller = T::CrossAccountId::from_eth(caller);567		let to = T::CrossAccountId::from_eth(to);568		let token_id: u32 = token_id.try_into()?;569		let budget = self570			.recorder571			.weight_calls_budget(<StructureWeight<T>>::find_parent());572573		if <TokensMinted<T>>::get(self.id)574			.checked_add(1)575			.ok_or("item id overflow")?576			!= token_id577		{578			return Err("item id should be next".into());579		}580581		let users = [(to.clone(), 1)]582			.into_iter()583			.collect::<BTreeMap<_, _>>()584			.try_into()585			.unwrap();586		<Pallet<T>>::create_item(587			self,588			&caller,589			CreateItemData::<T::CrossAccountId> {590				users,591				properties: CollectionPropertiesVec::default(),592			},593			&budget,594		)595		.map_err(dispatch_to_evm::<T>)?;596597		Ok(true)598	}599600	/// @notice Function to mint token with the given tokenUri.601	/// @param to The new owner602	/// @param tokenUri Token URI that would be stored in the NFT properties603	/// @return uint256 The id of the newly minted token604	#[solidity(rename_selector = "mintWithTokenURI")]605	#[weight(<SelfWeightOf<T>>::create_item())]606	fn mint_with_token_uri(607		&mut self,608		caller: caller,609		to: address,610		token_uri: string,611	) -> Result<uint256> {612		let token_id: uint256 = <TokensMinted<T>>::get(self.id)613			.checked_add(1)614			.ok_or("item id overflow")?615			.into();616		self.mint_with_token_uri_check_id(caller, to, token_id, token_uri)?;617		Ok(token_id)618	}619620	/// @notice Function to mint token with the given tokenUri.621	/// @dev `tokenId` should be obtained with `nextTokenId` method,622	///  unlike standard, you can't specify it manually623	/// @param to The new owner624	/// @param tokenId ID of the minted RFT625	/// @param tokenUri Token URI that would be stored in the RFT properties626	#[solidity(hide, rename_selector = "mintWithTokenURI")]627	#[weight(<SelfWeightOf<T>>::create_item())]628	fn mint_with_token_uri_check_id(629		&mut self,630		caller: caller,631		to: address,632		token_id: uint256,633		token_uri: string,634	) -> Result<bool> {635		let key = key::url();636		let permission = get_token_permission::<T>(self.id, &key)?;637		if !permission.collection_admin {638			return Err("Operation is not allowed".into());639		}640641		let caller = T::CrossAccountId::from_eth(caller);642		let to = T::CrossAccountId::from_eth(to);643		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;644		let budget = self645			.recorder646			.weight_calls_budget(<StructureWeight<T>>::find_parent());647648		if <TokensMinted<T>>::get(self.id)649			.checked_add(1)650			.ok_or("item id overflow")?651			!= token_id652		{653			return Err("item id should be next".into());654		}655656		let mut properties = CollectionPropertiesVec::default();657		properties658			.try_push(Property {659				key,660				value: token_uri661					.into_bytes()662					.try_into()663					.map_err(|_| "token uri is too long")?,664			})665			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;666667		let users = [(to.clone(), 1)]668			.into_iter()669			.collect::<BTreeMap<_, _>>()670			.try_into()671			.unwrap();672		<Pallet<T>>::create_item(673			self,674			&caller,675			CreateItemData::<T::CrossAccountId> { users, properties },676			&budget,677		)678		.map_err(dispatch_to_evm::<T>)?;679		Ok(true)680	}681682	/// @dev Not implemented683	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {684		Err("not implementable".into())685	}686}687688fn get_token_property<T: Config>(689	collection: &CollectionHandle<T>,690	token_id: u32,691	key: &up_data_structs::PropertyKey,692) -> Result<string> {693	collection.consume_store_reads(1)?;694	let properties = <TokenProperties<T>>::try_get((collection.id, token_id))695		.map_err(|_| Error::Revert("Token properties not found".into()))?;696	if let Some(property) = properties.get(key) {697		return Ok(string::from_utf8_lossy(property).into());698	}699700	Err("Property tokenURI not found".into())701}702703fn get_token_permission<T: Config>(704	collection_id: CollectionId,705	key: &PropertyKey,706) -> Result<PropertyPermission> {707	let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)708		.map_err(|_| Error::Revert("No permissions for collection".into()))?;709	let a = token_property_permissions710		.get(key)711		.map(Clone::clone)712		.ok_or_else(|| {713			let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();714			Error::Revert(alloc::format!("No permission for key {}", key))715		})?;716	Ok(a)717}718719/// @title Unique extensions for ERC721.720#[solidity_interface(name = ERC721UniqueExtensions)]721impl<T: Config> RefungibleHandle<T>722where723	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,724{725	/// @notice A descriptive name for a collection of NFTs in this contract726	fn name(&self) -> Result<string> {727		Ok(decode_utf16(self.name.iter().copied())728			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))729			.collect::<string>())730	}731732	/// @notice An abbreviated name for NFTs in this contract733	fn symbol(&self) -> Result<string> {734		Ok(string::from_utf8_lossy(&self.token_prefix).into())735	}736737	/// @notice A description for the collection.738	fn description(&self) -> Result<string> {739		Ok(decode_utf16(self.description.iter().copied())740			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))741			.collect::<string>())742	}743744	/// Returns the owner (in cross format) of the token.745	///746	/// @param tokenId Id for the token.747	fn cross_owner_of(&self, token_id: uint256) -> Result<EthCrossAccount> {748		Self::token_owner(&self, token_id.try_into()?)749			.map(|o| EthCrossAccount::from_sub_cross_account::<T>(&o))750			.ok_or(Error::Revert("key too large".into()))751	}752753	/// Returns the token properties.754	///755	/// @param tokenId Id for the token.756	/// @param keys Properties keys. Empty keys for all propertyes.757	/// @return Vector of properties key/value pairs.758	fn properties(&self, token_id: uint256, keys: Vec<string>) -> Result<Vec<PropertyStruct>> {759		let keys = keys760			.into_iter()761			.map(|key| {762				<Vec<u8>>::from(key)763					.try_into()764					.map_err(|_| Error::Revert("key too large".into()))765			})766			.collect::<Result<Vec<_>>>()?;767768		<Self as CommonCollectionOperations<T>>::token_properties(769			&self,770			token_id.try_into()?,771			if keys.is_empty() { None } else { Some(keys) },772		)773		.into_iter()774		.map(|p| {775			let key = string::from_utf8(p.key.to_vec())776				.map_err(|e| Error::Revert(alloc::format!("{}", e)))?;777			let value = bytes(p.value.to_vec());778			Ok(PropertyStruct { key, value })779		})780		.collect::<Result<Vec<_>>>()781	}782	/// @notice Transfer ownership of an RFT783	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`784	///  is the zero address. Throws if `tokenId` is not a valid RFT.785	///  Throws if RFT pieces have multiple owners.786	/// @param to The new owner787	/// @param tokenId The RFT to transfer788	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]789	fn transfer(&mut self, caller: caller, to: address, token_id: uint256) -> Result<void> {790		let caller = T::CrossAccountId::from_eth(caller);791		let to = T::CrossAccountId::from_eth(to);792		let token = token_id.try_into()?;793		let budget = self794			.recorder795			.weight_calls_budget(<StructureWeight<T>>::find_parent());796797		let balance = balance(self, token, &caller)?;798		ensure_single_owner(self, token, balance)?;799800		<Pallet<T>>::transfer(self, &caller, &to, token, balance, &budget)801			.map_err(dispatch_to_evm::<T>)?;802		Ok(())803	}804805	/// @notice Transfer ownership of an RFT806	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`807	///  is the zero address. Throws if `tokenId` is not a valid RFT.808	///  Throws if RFT pieces have multiple owners.809	/// @param to The new owner810	/// @param tokenId The RFT to transfer811	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]812	fn transfer_cross(813		&mut self,814		caller: caller,815		to: EthCrossAccount,816		token_id: uint256,817	) -> Result<void> {818		let caller = T::CrossAccountId::from_eth(caller);819		let to = to.into_sub_cross_account::<T>()?;820		let token = token_id.try_into()?;821		let budget = self822			.recorder823			.weight_calls_budget(<StructureWeight<T>>::find_parent());824825		let balance = balance(self, token, &caller)?;826		ensure_single_owner(self, token, balance)?;827828		<Pallet<T>>::transfer(self, &caller, &to, token, balance, &budget)829			.map_err(dispatch_to_evm::<T>)?;830		Ok(())831	}832833	/// @notice Transfer ownership of an RFT834	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`835	///  is the zero address. Throws if `tokenId` is not a valid RFT.836	///  Throws if RFT pieces have multiple owners.837	/// @param to The new owner838	/// @param tokenId The RFT to transfer839	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]840	fn transfer_from_cross(841		&mut self,842		caller: caller,843		from: EthCrossAccount,844		to: EthCrossAccount,845		token_id: uint256,846	) -> Result<void> {847		let caller = T::CrossAccountId::from_eth(caller);848		let from = from.into_sub_cross_account::<T>()?;849		let to = to.into_sub_cross_account::<T>()?;850		let token_id = token_id.try_into()?;851		let budget = self852			.recorder853			.weight_calls_budget(<StructureWeight<T>>::find_parent());854855		let balance = balance(self, token_id, &from)?;856		ensure_single_owner(self, token_id, balance)?;857858		Pallet::<T>::transfer_from(self, &caller, &from, &to, token_id, balance, &budget)859			.map_err(dispatch_to_evm::<T>)?;860		Ok(())861	}862863	/// @notice Burns a specific ERC721 token.864	/// @dev Throws unless `msg.sender` is the current owner or an authorized865	///  operator for this RFT. Throws if `from` is not the current owner. Throws866	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.867	///  Throws if RFT pieces have multiple owners.868	/// @param from The current owner of the RFT869	/// @param tokenId The RFT to transfer870	#[solidity(hide)]871	#[weight(<SelfWeightOf<T>>::burn_from())]872	fn burn_from(&mut self, caller: caller, from: address, token_id: uint256) -> Result<void> {873		let caller = T::CrossAccountId::from_eth(caller);874		let from = T::CrossAccountId::from_eth(from);875		let token = token_id.try_into()?;876		let budget = self877			.recorder878			.weight_calls_budget(<StructureWeight<T>>::find_parent());879880		let balance = balance(self, token, &from)?;881		ensure_single_owner(self, token, balance)?;882883		<Pallet<T>>::burn_from(self, &caller, &from, token, balance, &budget)884			.map_err(dispatch_to_evm::<T>)?;885		Ok(())886	}887888	/// @notice Burns a specific ERC721 token.889	/// @dev Throws unless `msg.sender` is the current owner or an authorized890	///  operator for this RFT. Throws if `from` is not the current owner. Throws891	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.892	///  Throws if RFT pieces have multiple owners.893	/// @param from The current owner of the RFT894	/// @param tokenId The RFT to transfer895	#[weight(<SelfWeightOf<T>>::burn_from())]896	fn burn_from_cross(897		&mut self,898		caller: caller,899		from: EthCrossAccount,900		token_id: uint256,901	) -> Result<void> {902		let caller = T::CrossAccountId::from_eth(caller);903		let from = from.into_sub_cross_account::<T>()?;904		let token = token_id.try_into()?;905		let budget = self906			.recorder907			.weight_calls_budget(<StructureWeight<T>>::find_parent());908909		let balance = balance(self, token, &from)?;910		ensure_single_owner(self, token, balance)?;911912		<Pallet<T>>::burn_from(self, &caller, &from, token, balance, &budget)913			.map_err(dispatch_to_evm::<T>)?;914		Ok(())915	}916917	/// @notice Returns next free RFT ID.918	fn next_token_id(&self) -> Result<uint256> {919		self.consume_store_reads(1)?;920		Ok(<TokensMinted<T>>::get(self.id)921			.checked_add(1)922			.ok_or("item id overflow")?923			.into())924	}925926	/// @notice Function to mint multiple tokens.927	/// @dev `tokenIds` should be an array of consecutive numbers and first number928	///  should be obtained with `nextTokenId` method929	/// @param to The new owner930	/// @param tokenIds IDs of the minted RFTs931	#[solidity(hide)]932	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]933	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {934		let caller = T::CrossAccountId::from_eth(caller);935		let to = T::CrossAccountId::from_eth(to);936		let mut expected_index = <TokensMinted<T>>::get(self.id)937			.checked_add(1)938			.ok_or("item id overflow")?;939		let budget = self940			.recorder941			.weight_calls_budget(<StructureWeight<T>>::find_parent());942943		let total_tokens = token_ids.len();944		for id in token_ids.into_iter() {945			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;946			if id != expected_index {947				return Err("item id should be next".into());948			}949			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;950		}951		let users = [(to.clone(), 1)]952			.into_iter()953			.collect::<BTreeMap<_, _>>()954			.try_into()955			.unwrap();956		let create_item_data = CreateItemData::<T::CrossAccountId> {957			users,958			properties: CollectionPropertiesVec::default(),959		};960		let data = (0..total_tokens)961			.map(|_| create_item_data.clone())962			.collect();963964		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)965			.map_err(dispatch_to_evm::<T>)?;966		Ok(true)967	}968969	/// @notice Function to mint multiple tokens with the given tokenUris.970	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive971	///  numbers and first number should be obtained with `nextTokenId` method972	/// @param to The new owner973	/// @param tokens array of pairs of token ID and token URI for minted tokens974	#[solidity(hide, rename_selector = "mintBulkWithTokenURI")]975	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]976	fn mint_bulk_with_token_uri(977		&mut self,978		caller: caller,979		to: address,980		tokens: Vec<(uint256, string)>,981	) -> Result<bool> {982		let key = key::url();983		let caller = T::CrossAccountId::from_eth(caller);984		let to = T::CrossAccountId::from_eth(to);985		let mut expected_index = <TokensMinted<T>>::get(self.id)986			.checked_add(1)987			.ok_or("item id overflow")?;988		let budget = self989			.recorder990			.weight_calls_budget(<StructureWeight<T>>::find_parent());991992		let mut data = Vec::with_capacity(tokens.len());993		let users: BoundedBTreeMap<_, _, _> = [(to.clone(), 1)]994			.into_iter()995			.collect::<BTreeMap<_, _>>()996			.try_into()997			.unwrap();998		for (id, token_uri) in tokens {999			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1000			if id != expected_index {1001				return Err("item id should be next".into());1002			}1003			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;10041005			let mut properties = CollectionPropertiesVec::default();1006			properties1007				.try_push(Property {1008					key: key.clone(),1009					value: token_uri1010						.into_bytes()1011						.try_into()1012						.map_err(|_| "token uri is too long")?,1013				})1014				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;10151016			let create_item_data = CreateItemData::<T::CrossAccountId> {1017				users: users.clone(),1018				properties,1019			};1020			data.push(create_item_data);1021		}10221023		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)1024			.map_err(dispatch_to_evm::<T>)?;1025		Ok(true)1026	}10271028	/// Returns EVM address for refungible token1029	///1030	/// @param token ID of the token1031	fn token_contract_address(&self, token: uint256) -> Result<address> {1032		Ok(T::EvmTokenAddressMapping::token_to_address(1033			self.id,1034			token.try_into().map_err(|_| "token id overflow")?,1035		))1036	}1037}10381039#[solidity_interface(1040	name = UniqueRefungible,1041	is(1042		ERC721,1043		ERC721Enumerable,1044		ERC721UniqueExtensions,1045		ERC721UniqueMintable,1046		ERC721Burnable,1047		ERC721Metadata(if(this.flags.erc721metadata)),1048		Collection(via(common_mut returns CollectionHandle<T>)),1049		TokenProperties,1050	)1051)]1052impl<T: Config> RefungibleHandle<T> where T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]> {}10531054// Not a tests, but code generators1055generate_stubgen!(gen_impl, UniqueRefungibleCall<()>, true);1056generate_stubgen!(gen_iface, UniqueRefungibleCall<()>, false);10571058impl<T: Config> CommonEvmHandler for RefungibleHandle<T>1059where1060	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,1061{1062	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueRefungible.raw");1063	fn call(1064		self,1065		handle: &mut impl PrecompileHandle,1066	) -> Option<pallet_common::erc::PrecompileResult> {1067		call::<T, UniqueRefungibleCall<T>, _, _>(handle, self)1068	}1069}